कार्य:

तीन इनपुट दिए जाने पर आपका काम है:

एक अंश n
एक भाजक d
एक और पूर्णांक, x

एक प्रोग्राम / फ़ंक्शन बनाएं xजो दशमलव स्थान के बाद संख्या के वें अंक को पाता है।

चश्मा:

की सीमा nऔर dके बीच है 1और 2^31 - 1समावेशी।
की सीमा के xबीच है 1और 10,000,000, समावेशी।
- आप 1-आधारित अनुक्रमणिका या 0-आधारित अनुक्रमणिका का उपयोग करना चुन सकते हैं x। कृपया अपने उत्तर में बताएं कि आप किसका उपयोग कर रहे हैं।
nसे बड़ा हो सकता है d।
n, dऔर xसकारात्मक पूर्णांक होने की गारंटी है (1-आधारित इंडेक्स संस्करण के लिए x, यदि आप 0-आधारित इंडेक्सिंग का उपयोग कर सकते हैं xतो आप xकर सकते हैं 0)।
आप किसी भी उचित तरीके से इनपुट ले सकते हैं (यानी किसी भी तरह से जो एक मानक खामी नहीं है)।

नियम:

आपको सटीक xवें अंक को वापस करना चाहिए , न कि गोल होने पर - इसलिए , उदाहरण के लिए, का 15वें अंक , लेकिन 1/6नहीं है ।76
xजब तक आपकी भाषा 10 मिलियन स्थानों पर दशमलव का समर्थन नहीं करती, तब तक आपके प्रोग्राम को सभी 10 मिलियन से कम में काम करना चाहिए ।

उदाहरण I / O:

उदाहरण के इनपुट 0-आधारित अनुक्रमण, जो साधन का उपयोग करता है xसे जाना होगा 0करने के लिए 9,999,999। साथ ही साथ, "इनपुट" को एक स्ट्रिंग के रूप में लिखा जाता है जिसमें रिक्त स्थान संख्याओं को अलग करता है।

1 2 3: 0
5 6 0: 8
5 6 1: 3
1 6 15: 6 (not 7, as it's not rounded)
1 11 2: 0
1 10000 9999999: 0
11 7 1: 7

code-golf math

— clismique
स्रोत

2

इस चुनौती का एक सबसेट है इस एक

— Bassdrop Cumberwubwubwub

8

मुझे यह भी नहीं लगता कि यह पीआई का एक सबसेट है, क्योंकि 1 विशिष्ट विशिष्ट संख्या के बारे में बात करता है, क्योंकि यह हर तर्कसंगत संख्या के बारे में बात करता है

— फेलिप नारदी बतिस्ता

2

कैसे एक उचित अंश के दशमलव विस्तार में n'th नंबर खोजने के लिए

— फेलिप नार्डी बतिस्ता

1

@FelipeNardiBatista हम्म् ... मैं तर्क दे सकता हूं कि यह विपरीत तरीका होना चाहिए, क्योंकि यह चुनौती पर्वतमाला और सामान के साथ अधिक निर्दिष्ट है (यह पहले हुआ है, जहां एक पुरानी चुनौती एक नई चुनौती के रूप में चिह्नित की गई है)। मुझे यकीन नहीं है, हालांकि।

— क्लिज्मिक

2

व्यायाम को आसानी से किया जा सकता है, यहाँ तक कि ऐसी भाषा में भी जिसका कोई बाइनम नहीं है ...

— RosLuP

12

पायथन 2 , 25 बाइट्स

पोर्ट ऑफ माई हास्केल उत्तर, चूंकि पायथन भी डिफॉल्ट रूप से बोगम का समर्थन करता है। वहाँ के रूप में, x1-अनुक्रमित है।

lambda n,d,x:n*10**x/d%10

इसे ऑनलाइन आज़माएं! (कीर्तन प्रभाकरन का रैपर उधार लेना।)

— अर्जन जोहान्सन
स्रोत

बहुत अच्छा, मैंने कुछ मिनट बिताए, "क्या यह वास्तव में इतना आसान था"? रूबी के लिए एक बंदरगाह केवल 21 बाइट्स होगा।

— जीबी

6

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

RealDigits[#/#2,10,1,-#3][[1,1]]&

1-आधारित अनुक्रमण।

जैसे दशमलव बिंदु के दाईं ओर 10 मिलियन अंकों का पाई:

%[Pi,1,10^7]
7

मेरी पुरानी मशीन पर लगभग 2 सेकंड लगते हैं।

आप इसे वुल्फरामअल्फा पर ऑनलाइन आज़मा सकते हैं (बराबर चिह्न पर क्लिक करें)

— केली लोडर
स्रोत

6

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

सभी परीक्षण मामलों के लिए काम करता है। याय बोगम!

(n#d)xलेता है Integerऔर एक लौटता है Integer। x1-अनुक्रमित है।

(n#d)x=n*10^x`div`d`mod`10

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

— अर्जन जोहान्सन
स्रोत

5

PHP> = 7.1, 40 बाइट्स

<?=bcdiv(($a=$argv)[1],$a[2],$a[3])[-1];

bcdiv

ऑनलाइन संस्करण

— जार्ग हुल्सरमैन
स्रोत

जब मैं आपका कोड  Notice: Uninitialized string offset: -1 in [...][...] on line 6 

— चलाऊंगा

@ Qwerp-Derp क्षमा करें, आपको PHP संस्करण gte 7.1 की आवश्यकता है और यह साइट पहली यात्रा है जो इसे सबसे उन्नत संस्करण में नहीं बदलेगी

— Jörg Hülsermann

4

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

⁵*×:ƓDṪ

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

एक फ़ंक्शन सबमिशन (लेकिन यह भी एक पूर्ण कार्यक्रम के रूप में काम करता है)। जेली फ़ंक्शन केवल दो तर्क ले सकता है सीधे; इस प्रकार मैं अंक को बाएं तर्क के रूप में वापस लेता हूं, अंश को सही तर्क के रूप में, और मानक इनपुट से भाजक (तीसरे तर्क का उपयोग करने के बदले में)।

जेली के लिए उपयोग किए जाने वाले लोगों को पता हो सकता है कि एक पूर्ण कार्यक्रम दो से अधिक तर्क ले सकता है, लेकिन ऐसा करने से आप लगातार पूर्णांक 10 लिखने के लिए सबसे कठिन तरीके से पहुंच खो सकते हैं, जो यहां काफी प्रासंगिक है। जैसे, इस तरह के मिश्रित इनपुट वास्तविक उपयोगी गोल्फिंग के बजाय कुछ हद तक एक शोषण की तरह महसूस करते हैं; मैं व्यक्तिगत रूप से इससे असहमत हूं, लेकिन इसे अनुमति देने के बारे में नियम वर्तमान में +40 / -12 पर है, इसलिए जब तक यह नियमों में है, तब तक मैं इसका फायदा उठा सकता हूं (और बहुत प्रतिस्पर्धात्मक होना चाहिए)।

1 का एक बायां तर्क दशमलव बिंदु (".1s अंक") के तुरंत बाद अंक को संदर्भित करता है, 2 से .01 के अंक का तर्क, और इसी तरह।

व्याख्या

⁵*×:ƓDṪ
⁵*        10 to the power of {the left argument}
  ×       multiplied by {the right argument}
   :      divided by
    Ɠ                standard input
      Ṫ   take the last
     D                  decimal digit

जेली में पूर्णांकों पर मनमाना-सटीक अंकगणित होता है, इसलिए 10 की शक्ति से पूर्व गुणा करके, हम प्रभावी रूप से उन अंकों को स्थानांतरित कर रहे हैं जो हम इकाइयों की स्थिति में चाहते हैं, जहां इसे निकालना बहुत आसान है।

4

सेड `-r` , 93 131 136 बाइट्स

s/$/,/
:d
s/,.+/,/
:
s/(1+)(1*;\1;1*,)1{10}?/\21/
t
s/1*/&&&&&&&&&&/
ta
:a
s/1,/,/
td
s/.+,//

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

( दशमलव में आउटपुट देखें )

यूनीरी में इनपुट्स और यूनरी में आउटपुट देता है, और प्रोग्राम 1-इंडेक्स किया गया है। शुक्र है कि इस चुनौती ने मुझे इसके लिए तैयार कर दिया है।

अवधारणा समान है, दोनों लंबे विभाजन को लागू करते हैं। यहाँ, मैं लंबे समय के विभाजन xसमय का प्रदर्शन करता हूँ , जहाँ xदशमलव स्थान के बाद का अंक है जिसे मुझे खोजना है। प्रत्येक पुनरावृत्ति के बाद, मैं पिछले दशमलव स्थानों को छोड़ देता हूं क्योंकि उन्हें अब आवश्यकता नहीं है।

विभाजन करते समय, कार्यक्रम प्रारूप में है dividend;divisor;x,result।

s/$/,/ इस अल्पविराम को जोड़ता है, परिणाम को बाकी सब से अलग करने के लिए अल्पविराम की आवश्यकता होती है

फिर मुख्य प्रोग्राम लूप का अनुसरण करता है

:d लेबल d

s/,.+/,/ अल्पविराम के बाद सब कुछ हटा दें
: खाली लेबल
- s/(1+)(1*;\1;1*,)1{10}?/\21/ विभाजन का प्रदर्शन करें, परिणाम में प्रत्येक पुनरावृत्ति को 1 जोड़ते हुए, परिणाम में 10 निरंतर 1s के ब्लॉक को एक साथ हटाते हुए
t खाली लेबल की शाखा, दूसरे शब्दों में, लूप जब तक लाभांश समाप्त नहीं हो जाता है
s/1*/&&&&&&&&&&/ अगली पुनरावृत्ति की तैयारी के लिए लाभांश को 10 से गुणा करें
ta शाखा लेबल करने के लिए a
:aलेबल ए, इस लाइन और ऊपर की लाइन को tdकाम करने के लिए आवश्यक है
s/1,/,/ x से 1 घटाएं

tdडी के लिए सशर्त शाखा, यह ट्रिगर होता है यदि अंतिम सशर्त शाखा के बाद से एक सफल प्रतिस्थापन s/1*/&&&&&&&&&&/हुआ है, हमेशा सफल रहा है, tdहमेशा ट्रिगर हो जाएगा, लेकिन शाखा को शुरू करने से, हम इसे ठीक करते हैं ताकि यह केवल पिछले प्रतिस्थापन पर निर्भर हो

s/.+,// अंत में, सब कुछ निकालें लेकिन परिणाम

— क्रिकटी लिथोस
स्रोत

3

रूबी , 34 33 बाइट्स

->n,d,x{(0..x).map{n=n%d*10};n/d}

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

— जीबी
स्रोत

3

REXX, 76 बाइट्स

(बहुत कम नहीं है, लेकिन यह REXX में एक करने के लिए एक परिवर्तन करना होगा सोचा) Rexx रक्षा द्वारा 1-आधारित है।

arg n d x
numeric digits x+10
y=n/d
parse var y "." +(x) z
say left(z,1,"0")

स्पष्टीकरण:

संख्याओं के लिए इनपुट पढ़ें
पर्याप्त महत्वपूर्ण अंकों की गारंटी दें (डिफ़ॉल्ट 9 है)
गणना
विभाजित करें। दशमलव बिंदु ढूंढें, "x" वर्णों की गणना करें, निम्नलिखित वर्ण लें और "z" में डालें
पहले अंक का प्रिंट आउट लें। पैड 0 के साथ सुनिश्चित करें।

सिंटैक्स में बदलाव के कारण 3 और 4 को मिलाना वास्तव में इसे लंबा बनाता है:

parse value n/d with "." +x z +1

गैर-आरईएक्सएक्सर्स के लिए: आरईएक्सएक्स में स्ट्रिंग्स और संख्या पूरी तरह से विनिमेय हैं। वे इस बात से निर्धारित होते हैं कि आप उन पर कैसे कार्य करते हैं। इसलिए आप बिना रूपांतरण के स्टिंग फ़ंक्शन का उपयोग करके नंबर पार्स कर सकते हैं। उदाहरण के लिए

"27" + "28"

55 और रिटर्न 2728 नहीं!

— बम बरसाना
स्रोत

क्या आप दुभाषिया के लिए एक लिंक जोड़ सकते हैं? मुझे लगता है कि कई उपयोगकर्ता इस भाषा से अपरिचित हैं।

— मेगो

tutorialspoint.com/execute_rexx_online.php केवल समस्या यह है कि मैं व्याख्याकार में इनपुट मान कैसे काम नहीं कर सकता। इसलिए, परीक्षण उद्देश्यों के लिए, मैंने शुरुआत में मूल्यों को निर्धारित करने के लिए असाइनमेंट का उपयोग किया।

— theblitz

1

यदि आप सीएलआई इनपुट जैसे देते हैं तो ऐसा लगता है कि दुभाषिया काम करता है rexx main.rexx 1 2 3। आपको अपने उत्तर में उल्लेख करना चाहिए कि इनपुट 1-अनुक्रमित है।

— मेगो

इनपुट संभावना पर ध्यान नहीं दिया क्योंकि मैंने सिर्फ शीर्ष पर निष्पादन बटन क्लिक किया था। ओह।

— theblitz

2

बैच, 70 बाइट्स

@set n=%1
@for /l %%x in (0,1,%3)do @set/an=n%%%2*10
@cmd/cset/an/%2

— नील
स्रोत

@FelipeNardiBatista ने मेरे लिए काम किया जब मैंने इसे आज़माया।

— नील

2

असेंबली इंटेल x86 सीपीयू भाषा, 50 बाइट्स

00000940  53                push ebx
00000941  8B5C240C          mov ebx,[esp+0xc]
00000945  8B4C2410          mov ecx,[esp+0x10]
00000949  31C0              xor eax,eax
0000094B  48                dec eax
0000094C  81C102000000      add ecx,0x2
00000952  721A              jc 0x96e
00000954  81FB00000000      cmp ebx,0x0
0000095A  7412              jz 0x96e
0000095C  8B442408          mov eax,[esp+0x8]
00000960  31D2              xor edx,edx
00000962  F7F3              div ebx
00000964  49                dec ecx
00000965  7407              jz 0x96e
00000967  8D0492            lea eax,[edx+edx*4]
0000096A  01C0              add eax,eax
0000096C  EBF2              jmp short 0x960
0000096E  5B                pop ebx
0000096F  C20C00            ret 0xc

nasm में traslation

; u32 __stdcall rdiv(u32 a, u32  b, u32 c)
; 8a, 12b, 16c
      align   4
rdiv:                   ; c<0xFFFFFFFE and b!=0
      push    ebx       ; something as for(;a=10*(a%b),c--;);return a/b
      mov     ebx,  dword[esp+  12]
      mov     ecx,  dword[esp+  16]
      xor     eax,  eax
      dec     eax
      add     ecx,  2
      jc      .z
      cmp     ebx,  0
      je      .z            
      mov     eax,  dword[esp+  8]
.1:   xor     edx,  edx
      div     ebx
      dec     ecx
      jz      .z
      lea     eax,  [edx+edx*4]
      add     eax,  eax
      jmp     short  .1     ; a=5*a;a+=a=>a=10*a
.z:       
      pop     ebx
      ret     12

पैरामीटर 'c' के लिए सीमा 0 से शुरू होती है; यह 0..0xfffffffd होगा। यदि पैरामीटर b = 0 या c सीमा से 0..0xfffffffd है तो यह -1 वापस आ जाएगा

— RosLuP
स्रोत

1

लुआ, 42 बाइट्स

function a(n,x,d)
print((n*10^x/d)%10)
end

— कॉनर बेलि
स्रोत

1

नमस्कार, और PPCG में आपका स्वागत है! यह एक महान पहला जवाब है!

— NoOneIsHere

1

सी, 49 43 बाइट्स

f(a,b,i){for(;a=10*(a%b),i--;);return a/b;}

'i' तर्क 0-इंडेक्सिंग है। टेस्ट कोड और परिणाम

main()
{int i;
 for(i=0;i<20;++i)
     printf("%u", f(12,11,i));

 printf("\nf(1,2,3)=%d\n",f(1,2,3));
 printf("f(5,6,0)=%d\n",f(5,6,0));
 printf("f(5,6,1)=%d\n",f(5,6,1));
 printf("f(1,6,15)=%d\n",f(1,6,15));
 printf("f(1,11,2)=%d\n",f(1,11,2));
 printf("f(1,10000,9999999)=%d\n",f(1,10000,9999999));
 printf("f(11,7,1)=%d\n",f(11,7,1));
}

f(1,2,3)=0
f(5,6,0)=8
f(5,6,1)=3
f(1,6,15)=6
f(1,11,2)=0
f(1,10000,9999999)=0
f(11,7,1)=7

— RosLuP
स्रोत

1

जावा 7, 146 139 137 133 128 122 बाइट्स

-3 बाइट्स के लिए धन्यवाद बृहत भक्षक व्यक्ति, मैं पूरी तरह से भूल आयात अपनी लाइन पर होना नहीं था

-4 बाइट्स धन्यवाद Qwerp-Derp के लिए निर्माणकर्ता के लिए n% d स्थानांतरित करने के लिए

-6 बाइट्स धन्यवाद केविन क्रूज़सेन को हटाने के लिए।

मुझे उम्मीद है कि आयात के साथ जावा कार्यों के लिए बाइट की गणना कैसे की जाती है

import java.math.*;char a(int n,int d,int x){return (new BigDecimal(n%d).divide(new BigDecimal(d),x+1,1)+"").charAt(x+2);}

दशमलव विस्तार का सटीक प्रतिनिधित्व पाने के लिए जावा के बिगडेसिमल वर्ग का उपयोग करता है। ध्यान दें कि यह अब तक का सबसे तेज़ चलने वाला कोड नहीं है, लेकिन यह अंततः सभी परीक्षण मामलों के लिए सही आउटपुट देता है। अघोषित कोड:

import java.math.*;
char a(int n, int d, int x){
    BigDecimal num = new BigDecimal(n%d); // reduce improper fractions
    BigDecimal div = new BigDecimal(d);
    BigDecimal dec = num.divide(div, x+1, 1); // precision of x + 1, round down
    return (dec+"").charAt(x+2); //xth char after decimal
}

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

— PunPun1000
स्रोत

कॉमा के बाद रिक्त स्थान और अर्धविराम के बाद की नई रूपरेखा को हटाया जा सकता है मुझे लगता है।

— आउटगोल्फर

मैं 137 बाइट्स

— कृति लिथोस

धन्यवाद दिया जाना चाहिए

— PunPun1000

क्या तुम सिर्फ BigDecimal(n)साथ नहीं ले सकते BigDecimal(n%d), और छुटकारा पा सकते हो n=n%d?

— क्लिस्मिक

आप इसे हटा सकते हैं .toString()और +""इसके बजाय (दो अतिरिक्त कोष्ठक के साथ) का उपयोग कर सकते हैं ।

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

1

क्लोजर, 39 बाइट्स

#(mod(int(/(*(Math/pow 10 %3)%)%2))10))

अनाम फ़ंक्शन तर्कों के साथ n,d,xजहां xएक आधारित अनुक्रमण का उपयोग करता है।

— मतिस ब्रजलैंड
स्रोत

1

एफ # (.NET कोर) , 30 बाइट्स

let f n d x=n*pown 10I x/d%10I

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

(1-आधारित अनुक्रमण का उपयोग करें)

— बस एक और रूपक
स्रोत

मैं 33 बाइट्स गिनता हूं। मैं इसे ऑनलाइन आज़माना चाहूंगा ! संपर्क।

— 19'18

मेरे क्लिपबोर्ड में गलत कार्य था। धन्यवाद।

— बस एक और रूपकग्राम

1

ग्रूवी, 30 बाइट्स

{n,d,x->(n*10**x/d as int)%10}

x 1 आधारित अनुक्रमण का उपयोग करता है।

स्पष्टीकरण:

{n,d,x->    // closure with three arguments, n, d, x
 n*10**x    // multiply n with 10 to the power of x
 /d         // divide by d
 as int     // convert from BigDecimal to int
 )%10       // modulo 10 to get the answer
}

— मतिस ब्रजलैंड
स्रोत

0

अजगर 2 , 50,44,40, 36 बाइट्स

lambda n,d,x:(`n*1./d%1`+'0'*x)[x+2]

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

— कीर्तन प्रभाकरं
स्रोत

के लिए काम नहीं करता है1,7,10000000

— फेलिप नारदी बतिस्ता

0

रूबी, 39 बाइट्स

->n,m,o{(n*1.0/m).to_s.split(?.)[1][o]}

— dkudriavtsev
स्रोत

0

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

(n,d,x)=>`${n/d}`.split`.`[1][x]|0

x 0-आधारित है

f=
(n,d,x)=>`${n/d}`.split`.`[1][x]|0

console.log(f(1,2,3))
console.log(f(5,6,0))
console.log(f(5,6,1))
console.log(f(1,6,15))
console.log(f(1,11,2))
console.log(f(1,10000,10000000))
console.log(f(11,7,1))
console.log(f(2000,7,0))

स्निपेट का विस्तार करें

— Weedoze
स्रोत

दुर्भाग्य से, मेरे समाधान की तरह, यह लंबे दशमलव के साथ विफल हो जाएगा; f(1,7,10000000)उदाहरण के लिए प्रयास करें ।

— झबरा

0

पायथन 2 , 32 बाइट्स

0-इंडेक्सिंग का उपयोग करता है

lambda n,d,x:int(10**-~x*n/d)%10

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

संपादित करें:

मूल समाधान में वापस लौटा जैसा कि अर्जन जोहान्सन के जवाब में देखा गया है कि यह काम करता है, लेकिन मैं इसे आगे नहीं बढ़ाऊंगा

— फेलिप नारदी बतिस्ता
स्रोत

2

यदि यह मान्य नहीं है तो इसे हटा दिया जाना चाहिए।

— आउटगोल्फर

अब तक के अधिकांश जवाबों के अनुसार

— फेलिप नारदी बतिस्ता

@EriktheOutgolfer ने इसे तय किया ...

— फेलिप

क्या आप 1-इंडेक्सिंग का उपयोग करते हैं?

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

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

— जोनाथन एलन

0

ग्रूवी, 55 बाइट्स

{n,d,x->z='0'*x;Eval.me("$n.$z/$d.$z").toString()[x-1]}

का उपयोग कर समझाया 1,11,2:

{
    n,d,x->          // I've already lost to Jelly by the end of this line.
    z='0'*x;         // Set z equal to 2 0's.
    Eval.me          // Evaluate as groovy code...
    ("$n.$z/$d.$z")  // 1.00g/11.00g (Automatically set precision using # 0s).
   .toString()[x-1]  // Get 2nd digit of division.
}

— जादू ऑक्टोपस Urn
स्रोत

0

Axiom, 71 61 76 बाइट्स

f(a:NNI,b:PI,n:NNI):NNI==(repeat(a:=10*(a rem b);n=0=>break;n:=n-1);a quo b)

n 0-इंडेक्सिंग [0..M] है। टेस्ट कोड और परिणाम

(19) ->    f(1,2,3)=0
   (19)  0= 0
(20) ->     f(5,6,0)=8
   (20)  8= 8
(21) ->     f(5,6,1)=3
   (21)  3= 3
(22) ->     f(1,6,15)=6
   (22)  6= 6
(23) ->     f(1,11,2)=0
   (23)  0= 0
(24) ->     f(1,10000,9999999)=0
   (24)  0= 0
(25) ->     f(11,7,1)=7
   (25)  7= 7

— RosLuP
स्रोत

0

जावास्क्रिप्ट (Node.js) , 43 बाइट्स, पोर्ट

(a,b,i)=>eval(`for(;a=10*(a%b),i--;)a/b|0`)

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

जावास्क्रिप्ट (Node.js) , 51 बाइट्स

(n,d,x)=>[...Array(x)].map(_=>[n*=10,u=n/d,n%=d])|u

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

उपयोग सरणी से बचने के लिए नहीं बल्कि पुनरावर्ती से stackoverflow

— l4m2
स्रोत

दशमलव प्राप्त करें!

कार्य:

चश्मा:

नियम:

उदाहरण I / O:

पायथन 2 , 25 बाइट्स

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

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

PHP> = 7.1, 40 बाइट्स

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

व्याख्या

सेड -r , 93 131 136 बाइट्स

रूबी , 34 33 बाइट्स

REXX, 76 बाइट्स

बैच, 70 बाइट्स

असेंबली इंटेल x86 सीपीयू भाषा, 50 बाइट्स

लुआ, 42 बाइट्स

सी, 49 43 बाइट्स

जावा 7, 146 139 137 133 128 122 बाइट्स

क्लोजर, 39 बाइट्स

एफ # (.NET कोर) , 30 बाइट्स

ग्रूवी, 30 बाइट्स

अजगर 2 , 50,44,40, 36 बाइट्स

रूबी, 39 बाइट्स

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

पायथन 2 , 32 बाइट्स

ग्रूवी, 55 बाइट्स

Axiom, 71 61 76 बाइट्स

जावास्क्रिप्ट (Node.js) , 43 बाइट्स, पोर्ट

जावास्क्रिप्ट (Node.js) , 51 बाइट्स

सेड `-r` , 93 131 136 बाइट्स