30

कुछ के साथ सकारात्मक पूर्णांक की एक सूची के इनपुट को देखते हुए 0, उस सूची को आउटपुट करते हैं जो लापता संख्याओं के साथ बदल दिया गया 0था।

इनपुट सूची के लक्षण:

सूची में हमेशा कम से कम 2 की लंबाई होगी।
आइए हम इनपुट सूची को a"मूल सूची" के रूप में परिभाषित करते हैं (यानी, संख्याओं से पहले की सूची को 0s के साथ बदल दिया गया ) b। किसी के लिए n, या a[n]तो है ।b[n]0
किसी के लिए n, या b[n]तो है । यही है, संख्या हमेशा अपने पिछले से प्रत्येक सूचकांक में बदल जाएगी । पहला तत्व, निश्चित रूप से, इस नियम से छूट है।b[n-1] + 1b[n-1] - 1b1
में शून्य की हर रन के लिए a(जो है, लगातार साथ प्रतिस्थापित तत्वों 0) के साथ, xरन की शुरुआत के सूचकांक का प्रतिनिधित्व करने और y , अंत का प्रतिनिधित्व करने a[x-1]के लिए a[y+1]हमेशा या तो पूरी तरह से बढ़ रही हो जाएगा या पूरी तरह से कम करें। इसलिए, शून्य में भरने के लिए केवल एक ही संभव तरीका होगा।
- इसका मतलब यह भी है कि सरणी का न तो पहला और न ही अंतिम तत्व शून्य हो सकता है।

सरल शब्दों में, शून्य के एक भाग को भरने के लिए, बस इसे संख्या से पहले की संख्या के साथ प्रतिस्थापित करें, इसके बाद की संख्या के लिए। उदाहरण के लिए, का एक इनपुट

1 2 0 0 0 6 7

उत्पादन करना चाहिए

1 2 3 4 5 6 7

चूंकि यह कोड-गोल्फ है , बाइट्स में सबसे छोटा कोड जीत जाएगा।

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

In                      Out
-----------------------------------------------------
1 0 0 0 5 6 0 4 0 0 1 | 1 2 3 4 5 6 5 4 3 2 1
7 6 0 0 3 0 0 0 7 0 5 | 7 6 5 4 3 4 5 6 7 6 5
1 0 3 0 5 0 3 0 5 0 7 | 1 2 3 4 5 4 3 4 5 6 7
14 0 0 0 0 0 0 0 0 23 | 14 15 16 17 18 19 20 21 22 23

code-golf number array-manipulation

— Doorknob
स्रोत

0हमारे कार्यक्रम के बजाय एक और मूल्य ले सकते हैं जैसे null?

— डाउनगेट

@Downgoat नहीं, लापता संख्या के रूप में दिया जाना चाहिए 0।

— दरवाज़े

15

जावास्क्रिप्ट (ईएस 6), 72 66 64 54 53 बाइट्स

12 बाइट्स @Neil की बदौलत बची!

@IsmaelMiguel को 1 बाइट धन्यवाद दिया गया

a=>a.map((l,i)=>l?b=l:b+=a.find((q,r)=>r>i&&q)>b||-1)

जावास्क्रिप्ट के लिए बहुत अच्छा है।

इसे ऑनलाइन आज़माएं (सभी ब्राउज़र काम करते हैं)

व्याख्या

a=>  // Function with arg `a`
  a.map((l,i)=>  // Loop through input
    l?             // If nonzero
      b=l          // Set `b` to current number
    :a.find((q,r)=>r>i&q) // Otherwise look for the next nonzero number
     >b?           // If it's increased since nonzero last number   
       ++b:--b)    // Increasing? increase `b` (the previous nonzero number)
                   // otherwise decrease `b`

— Downgoat
स्रोत

1

मुझे लगता है कि a.find((q,r)=>r>i&&q)>b?++b:--bऐसा ही हैb+=a.find((q,r)=>r>i&&q)>b||-1

— इस्माइल मिगुएल

@IsmaelMiguel स्मार्ट है, धन्यवाद!

— डाउनगेट

आपका स्वागत है। मुझे खुशी है कि इसने आपके लिए काम किया।

— इस्माइल मिगुएल

मुझे लगता है कि आप सिर्फ & amp के साथ && को प्रतिस्थापित कर सकते हैं (बस आपको एक और स्पष्टीकरण में और उत्तर में दो पर ध्यान दिया गया है)

— चार्ली व्यान

7

MATL , 11 12 बाइट्स

fGXzGn:3$Yn

भाषा / संकलक की वर्तमान रिलीज़ (13.0.0) के साथ काम करता है ।

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

f        % implicitly input array. Indices of nonzero elements (*)
GXz      % push input and get its nonzero elements (**)
Gn:      % vector [1,2,...,n], where n is input length (***)
3$Yn     % interpolate at positions (***) from data (**) defined at positions (*)

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

7

हास्केल, 68 61 58 बाइट्स

g(a:b:r)=[a..b-1]++[a,a-1..b+1]++g(b:r)
g x=x
g.filter(>0)

प्रयोग उदाहरण: g.filter(>0) $ [7,6,0,0,3,0,0,0,7,0,5]-> [7,6,5,4,3,4,5,6,7,6,5]।

यह कैसे काम करता है: इनपुट से शून्य हटा दें, फिर कॉल करें g। चलो aपहला और हो bशेष सूची की तो दूसरा तत्व। aऊपर b-1से aनीचे और नीचे से b+1(उनमें से एक खाली हो जाएगा) और नीचे के साथ एक पुनरावर्ती कॉल की सूचियों को aसमाप्‍त करें।

संपादित करें: @Zgarb ने 3 बाइट्स बचाए। धन्यवाद!

— nimi
स्रोत

6

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

#//.{a___,x_,0..,y_,b___}:>{a,##&@@Range[x,y,Sign[y-x]],b}&

परीक्षण का मामला

%[{1,0,3,0,5,0,3,0,5,0,7}]
(* {1,2,3,4,5,4,3,4,5,6,7} *)

— njpipeorgan
स्रोत

4

पर्ल, 47 45 44 39 37 बाइट्स

के लिए +1 शामिल है -p

s%\S+%$p+=/\G(0 )+/?$'<=>$p:$&-$p%eg

स्टड पर सूची की उम्मीद है। उदाहरण: गूंज 1 0 3 0 1 | perl -p file.pl

— टन हास्पेल
स्रोत

मैं कुछ कॉपी पेस्ट कर रहा हूँ यहाँ ..; ;-) अच्छी तरह से किया btw।

— केनी

3

जेली, 12 11 बाइट्स

ḢWW;ḟ0Ṫr¥\F

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

वैकल्पिक संस्करण, 8 बाइट्स (गैर-प्रतिस्पर्धात्मक)

दुर्भाग्यवश, जेली popइस चुनौती से पहले के नवीनतम संस्करण में पुनरावृत्ति के लिए तैयार नहीं हुई। यह ठीक कर दिया गया है, और वर्तमान संस्करण में निम्नलिखित काम करता है।

ḟ0Ṫr¥\FḊ

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

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

ḢWW;ḟ0Ṫr¥\F  Main link. Input: A (list)

Ḣ            Pop the first element of A. Let's call it a.
 WW          Yield [[a]].
   ;         Concatenate with the popped A.
             This wraps the first element of A in an array.
    ḟ0       Filter; remove all zeroes.
        ¥    Create a dyadic chain:
      Ṫ        Pop the last element of the left argument.
       r       Call range on the popped element and the right argument.
         \   Reduce the modified A by this chain.
          F  Flatten the resulting list of ranges.

वैकल्पिक संस्करण में, ḢWW;अनावश्यक हो जाता है। हालांकि, चूंकि पहला तत्व पॉपिंग से पहले पुनरावृत्ति के लिए डाला जाता है, यह वास्तव में संशोधित नहीं है। अंतिम Ḋपहले तत्व के डुप्लिकेट को निकालता है।

— डेनिस
स्रोत

3

रेटिना, 39 34 31 बाइट्स

3 बाइट्स @Martin के लिए धन्यवाद बचा लिया।

+`1(1*) (?= +((1)\1)?)
$0$1$3$3

इनपुट लेता है और unary में आउटपुट देता है।

कोड iteratively हर खाली जगह (0 के) को भरता है previous_number - 1 + 2 * if_next_nonzero_number_bigger। previous_number - 1है $1और if_next_nonzero_number_biggerहै $3।

दशमलव I / O के साथ कोड 51 बाइट्स लंबा है जब तक कि आप सभी परीक्षण मामलों के साथ ऑनलाइन दुभाषिया में देख सकते हैं ।

— randomra
स्रोत

आप लुकहेड में पहले को छोड़ कर एक और बाइट बचा सकते हैं 1।

— मार्टिन एंडर

@ मार्टिनबटनर राइट, संपादित।

— यादृच्छिक

2

जीएनयू सैड ( `exec`बैश का उपयोग करके विस्तार के साथ ), 61

स्कोर में -rsed के विकल्प के लिए +1 शामिल है ।

:
s/( 0)+ /../
s/\w+..\w+/{&}/
s/.*/bash -c 'echo &'/e
/ 0/b

रनों का पता लगाएं 0और उन्हें बदल दें..
{1..4}स्थानीय समापन बिंदु की तरह बैश ब्रेस विस्तार बनाने के लिए समापन बिंदु संख्या के आसपास ब्रेसिज़ रखें । बैश ब्रेस विस्तार की सुंदरता यहां यह है कि उत्पन्न अनुक्रम हमेशा सही दिशा में चलेगा, चाहे शुरुआत या अंत बड़ा हो।
इस ब्रेस विस्तार का मूल्यांकन करने के लिए बैश करने के लिए कॉल eकरने के लिए sकमांड के विकल्प का उपयोग करें
यदि कोई अधिक 0एस पाया जाता है, तो शुरू में वापस कूदो।

Ideone।

— डिजिटल आघात
स्रोत

2

अजगर 2, 195 111 बाइट्स (धन्यवाद एलेक्स !)

t=input()
z=0
for i,e in enumerate(t):
 if e:
  while z:t[i-z]=e+z if l>e else e-z;z-=1
  l=e
 else:z+=1
print t

इनपुट: एक [list]ints होना चाहिए
आउटपुट: [list]ints का

— vageli
स्रोत

उसके लिए माफ़ करना! फिक्स्ड। सर उठाने के लिए धन्यवाद।

— योनि

कोई चिंता नहीं। अच्छा समाधान है। :) आप इसे का उपयोग कर 112 बाइट्स के लिए नीचे मिल सकती है इस जो अपने ही दृष्टिकोण है, बस थोड़ा अधिक golfed। हमारे पास यहां पायथन में गोल्फ के लिए युक्तियों का संग्रह भी है ।

— एलेक्स ए।

1

पर्ल, 85 82 बाइट्स

के लिए +1 शामिल है -p

s/(\d+)(( 0)+) (\d+)/$s=$1;$e=$4;$_=$2;$c=$s;s!0!$c+=$e<=>$s!eg;"$s$_ $e"/e&&redo

स्टड पर सूची की उम्मीद है। उदाहरण: echo 1 0 3 0 1 | perl -p file.pl।

यह एक नेस्टेड regexp का उपयोग करता है। कुछ पठनीय:

s/(\d+)(( 0)+) (\d+)                  # match number, sequence of 0, number
 /
    $s=$1;                            # start number
    $e=$4;                            # end number
    $_=$2;                            # sequence of ' 0'
    $c=$s;                            # initialize counter with start number
    s!0! $c += $s <=> $e !eg          # replace all 0 with (in|de)cremented counter
    "$s$_ $e"                         # return replacement
 /e
&& redo                               # repeat until no more changes.

— केनी
स्रोत

1

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

(हटाया गया मध्यवर्ती चर)

t=filter(bool,input())
print sum([range(o,p,cmp(p,o))for o,p in zip(t,t[1:])],[])+t[-1:]

— orez
स्रोत

1

पायथ, 17 बाइट्स

u+G+treGHHfTtQ[hQ

जिस तरह से यह काम करता है:

u                 reduce
              [hQ     seed: the first element of input, in a list
                      iterable:
          tQ              all except the first element of input
        fT                remove if 0
                      lambda: G is the list to be returned, H is the current item
 +G                       append to return list
    reGH                  a range from the last element of the return list and the current item
   +                      concatenated with
        H                 the last item (this step forms a bidirectional inclusive list)

दूसरे शब्दों में: सभी शून्य इनपुट से हटा दिए जाते हैं, फिर प्रत्येक तत्व के बीच एक विशेष श्रेणी डाली जाती है। यह सीमा केवल एक के अलावा तत्वों पर शून्य लंबाई है।

— कैमरन मैक्लुस्की
स्रोत

1

05AB1E , 3 बाइट्स (गैर-प्रतिस्पर्धात्मक)

यह चुनौती के बाद जोड़ा गया एक फीचर था। कोड:

0KŸ

स्पष्टीकरण:

0K   # Remove all zeroes from the input list
  Ÿ  # Rangify, [1, 4, 1] would result into [1, 2, 3, 4, 3, 2, 1]

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

— अदनान
स्रोत

1

विम: 231 प्रमुख कमांड

ध्यान दें कि किसी भी वर्ण से पहले ^ का मतलब है कि आपको उस चरित्र को लिखते समय नियंत्रण रखना चाहिए

mbomayiwo^V^R"^V^V^V^X ^V^["sy0dd`a@f ^["bc0yiwo^V^V^V^X^V^R"^V^[0l@sa^V^V^V^A-^V^[0f-"ayhdd`a@i ^["dc0mbyiwo^V^R"Exe@b^V^[0fel"ty2ldd`b@t ^["ec0wmbyiwo@f @d^V^[@z ^["fc0"xyiwwmbyiwocw^V^V^V^Rx^V^V^V^[@a@i @e^V^[@z ^["ic0IB0 B^V^R" ^V^OWB0 ^V^OA B0^V^[0*w"tyiWdd`b@t ^["zd0dd`bAe^[0@e

कदम ताकि आप भी इसे चला सकें!

लाइन को विम में कॉपी करें
टाइप करें :s/\^V/<Ctrl-V><Ctrl-V>/gऔर एंटर दबाएं (दो एस आपको एक नीला ^ वी देना चाहिए)
टाइप करें :s/\^R/<Ctrl-V><Ctrl-R>/gऔर एंटर दबाएं (आपको नीला ^ अब देखना चाहिए)
टाइप करें :s/\^X/<Ctrl-V><Ctrl-X>/gऔर एंटर दबाएं (आपको नीला ^ Xs अभी देखना चाहिए)
टाइप करें :s/\^O/<Ctrl-V><Ctrl-O>/gऔर एंटर दबाएं
टाइप करें :s/\^A/<Ctrl-V><Ctrl-A>/gऔर एंटर दबाएं
टाइप करें :s/\^\[/<Ctrl-V><Ctrl-[>/gऔर एंटर करें (यह कमांड थोड़ा अलग है क्योंकि मुझे बचने के लिए आवश्यक था [)
टाइप करें 0"yy$। कमांड अब y रजिस्टर में संग्रहीत है
एक लाइन पर इनपुट सेट करें, और साथ चलाएं @y

यदि कोई व्यक्ति कमांड साझा करने का बेहतर तरीका जानता है, तो कृपया मुझे बताएं। मुझे पता है कि यह लंबा है, लेकिन यह सबसे अच्छा है जिसके साथ मैं आ सकता हूं।

इनपुट आउटपुट

फाइल में किसी भी लाइन पर इनपुट स्ट्रिंग अकेले होनी चाहिए। 1 0 0 4 3 0 0 0 7

आउटपुट केवल इनपुट स्ट्रिंग 1 2 3 4 3 4 5 6 7 को अधिलेखित करेगा

व्याख्या

कलन विधि

एक गैर-शून्य नंबर पर शुरू करें, सुनिश्चित करें कि यह अंतिम संख्या नहीं है
अगले गैर-शून्य संख्या का पता लगाएं
उनका अंतर लो। यदि उत्तर नकारात्मक है, तो आपको सीमा को सुधारने के लिए वेतन वृद्धि करनी चाहिए, अन्यथा सीमा को सुधारने के लिए वेतन वृद्धि।
पहले वर्ण पर वापस जाएं और पिछले संख्या को बढ़ा / घटाकर प्रत्येक शून्य को बदलें।
तब तक दोहराएं जब तक आप आखिरी पात्र तक नहीं पहुंच जाते

मैक्रोस का इस्तेमाल किया

@e - अंत के लिए जाँच करें। अंतिम संख्या में एक ई संलग्न होगा। यदि कर्सर के नीचे की संख्या में अंत में ई है, तो ई हटाएं और निष्पादन को रोक दें। अन्यथा, @ बी के साथ एक प्रक्षेप चक्र शुरू करें।

mbyiwo^R"Exe@b^[0fel"ty2ldd`b@t

@ बी - प्रक्षेप चक्र शुरू करें। घटाव ऑपरेशन (@s) के लिए कर्सर के नीचे की संख्या को सहेजें और फिर अगला गैर-शून्य शब्द (@f) ढूंढें।

mayiwo^R"^V^X ^["sy0dd`a@f

@ एस - @ डी में उपयोग करने के लिए घटाव कमांड को स्टोर करता है। यह केवल वह (val)^Xजगह (val)है जहां प्रक्षेप कदम की शुरुआत में संख्या है। यह @b कमांड द्वारा सेट किया गया है।

@f - अगला गैर-शून्य शब्द खोजें। अनाम मान को वर्तमान मान लिखें, फिर @f @dअगली पंक्ति पर लिखें , और फिर @z चलाएं। यदि संख्या शून्य है, तो यह इस आदेश को दोहराएगा और यदि यह नहीं है तो @d निष्पादित करें।

wmbyiwo@f @d^[@z

@z - अनाम पंजिका होने पर सशर्त क्रियान्वयन 0. यह कमांड प्रारूप में एक नई लाइन पर दो कमांड की उम्मीद करता है command1 command2। यदि अनाम कोड 0 है, command1तो निष्पादित किया जाता है, अन्यथा command2निष्पादित किया जाता है। ध्यान दें कि न तो कमांड में कोई स्पेस हो सकता है।

 IB0 B^R" ^OWB0 ^OA B0^[0*w"tyiWdd`b@t`

@ टी - अस्थाई कमांड रजिस्टर। उन्हें क्रियान्वित करने से पहले थोड़े समय के लिए विभिन्न कमांड स्टोर करें। मुख्य रूप से अगर बयानों में उपयोग किया जाता है।

@d - प्रक्षेप दिशा निर्धारित करें। कर्सर (@ का उपयोग करके) के तहत संख्या से अनुक्रम में पहले नंबर को घटाता है। यदि परिणाम नकारात्मक है, तो प्रक्षेप को घटाना होगा इसलिए ^ X को @a में सहेजा गया है। अन्यथा, हमें वेतन वृद्धि करनी चाहिए ताकि ^ ए @ @ को बचाया जाए। एक बार जब यह सहेजा जाता है, तो इस प्रक्षेप चक्र की शुरुआत में वापस जाएं और @i को वास्तव में प्रक्षेपित करें

yiwo^V^X^R"^[0l@sa^V^A-^[0f-"ayhdd`a@i

@a - स्टोर या तो ^Aया ^Xप्रक्षेप चरण के दौरान वेतन वृद्धि या कमी करने के लिए। यह @d कमांड द्वारा सेट किया गया है।

@ आई - इंटरपोलेट। वर्तमान स्थान पर नंबर को @x पर कॉपी करें और अगले नंबर पर जाएं। यदि वह संख्या शून्य है, तो इसे @x से बदलें और @a को ठीक से ऊपर या नीचे संशोधित करने के लिए चलाएं, फिर इस आदेश को दोहराएं। यदि संख्या शून्य नहीं है, तो हम इस प्रक्षेप चक्र के अंत तक पहुँच चुके हैं। शुरुआत के रूप में इस नंबर के साथ एक नया शुरू किया जाना चाहिए, इसलिए अंत की जांच करने के लिए @e चलाएं और फिर से चलाएं।

"xyiwwmbyiwocw^V^Rx^V^[@a@i @e^[@z

@x - अस्थायी संग्रहण रजिस्टर। प्रक्षेप कमांड (@i) में प्रयुक्त

कीस्ट्रोक्स को तोड़ना

mbo :Set b mark to current position and open a new line below to write macros
mayiwo^V^R"^V^V^V^X ^V^["sy0dd`a@f ^["bc0 :Write to @b and reset line

yiwo^V^V^V^X^V^R"^V^[0l@sa^V^V^V^A-^V^[0f-"ayhdd`a@i ^["dc0 :Write to @d and reset line

mbyiwo^V^R"Exe@b^V^[0fel"ty2ldd`b@t ^["ec0 :Write to @e and reset line

wmbyiwo@f @d^V^[@z ^["fc0 :Write to @f and reset line

"xyiwwmbyiwocw^V^V^V^Rx^V^V^V^[@a@i @e^V^[@z ^["ic0 :Write to @i and reset line

IB0 B^V^R" ^V^OWB0 ^V^OA B0^V^[0*w"tyiWdd`b@t ^["zd0 :Write to @z and reset line

dd`b :Delete this line and move cursor back to original line

Ae^[ :Append an e to the last number

0@e  :Move to the beginning of the line and run

— डोमिनिक ए।
स्रोत

0

पायथन 3.5, 159 बाइट्स

एक पुनरावर्ती समाधान

def f(s):
 h=s[0]
 g=lambda s,h,v:h*(h[-1]==s[0])if len(s)==1else(g(s[1:],h+[h[-1]-v],-v)+g(s[1:],h+[h[-1]+v],+v))*(s[0]==0 or h[-1]==s[0])
 return g(s,[h],1)

Ungolfed

def f(s):
    h=s[0]
    def g(s,h,v):
        if len(s)==1:
            if h[-1]!=s[0]:
                r=[]
            else:
                r=h
        else:
            if s[0]==0:
                r=g(s[1:],h+[h[-1]+v],v)
            elif h[-1]!=s[0]:
                r=[]
            else:
                r=g(s[1:],h+[h[-1]-v],-v)+g(s[1:],h+[h[-1]+v],+v)
        return r
return g(s,[h],1)

गोल्फ समाधान में, मैं इस तथ्य का उपयोग करके स्थितियों को प्रतिस्थापित करता हूं कि h*True=hऔरh*False=[]

परिणाम

>>> f([7, 6, 0, 0, 3, 0, 0, 0, 7, 0, 5])
[7, 6, 5, 4, 3, 4, 5, 6, 7, 6, 5]

— एर्वान
स्रोत

0

पर्ल 6 , 54 बाइट्स

{$_=$^a;1 while s/:s(\d+) 0 + (\d+)/{+~$0...+~$1}/;$_}

— SMLS
स्रोत

0

MATLAB, 39 38 37 बाइट्स

@(a)interp1(find(a),a(a>0),find(a/0))

बेनामी फ़ंक्शन जो रैखिक बिंदुओं के बीच में अंतर करता है a। find(a)गैर-शून्य तत्वों के सूचकांकों की एक सरणी है aऔर a(a>0)सकारात्मक मूल्य हैं। >बजाय एक दोस्त के सुझाव के लिए 1 बाइट धन्यवाद सहेजा ~=।

— MattWH
स्रोत

पर्वतमाला की मरम्मत करें

जावास्क्रिप्ट (ईएस 6), 72 66 64 54 53 बाइट्स

व्याख्या

MATL , 11 12 बाइट्स

हास्केल, 68 61 58 बाइट्स

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

पर्ल, 47 45 44 39 37 बाइट्स

जेली, 12 11 बाइट्स

वैकल्पिक संस्करण, 8 बाइट्स (गैर-प्रतिस्पर्धात्मक)

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

रेटिना, 39 34 31 बाइट्स

जीएनयू सैड ( execबैश का उपयोग करके विस्तार के साथ ), 61

अजगर 2, 195 111 बाइट्स (धन्यवाद एलेक्स !)

पर्ल, 85 82 बाइट्स

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

पायथ, 17 बाइट्स

05AB1E , 3 बाइट्स (गैर-प्रतिस्पर्धात्मक)

विम: 231 प्रमुख कमांड

कदम ताकि आप भी इसे चला सकें!

इनपुट आउटपुट

व्याख्या

कलन विधि

मैक्रोस का इस्तेमाल किया

कीस्ट्रोक्स को तोड़ना

पायथन 3.5, 159 बाइट्स

Ungolfed

परिणाम

पर्ल 6 , 54 बाइट्स

MATLAB, 39 38 37 बाइट्स

जीएनयू सैड ( `exec`बैश का उपयोग करके विस्तार के साथ ), 61