31

इस तरह से केवल गैर-नकारात्मक पूर्णांक वाले गैर-खाली सूची / सरणी को देखते हुए:

[0, 0, 0, 8, 1, 4, 3, 5, 6, 4, 1, 2, 0, 0, 0, 0]

हटाए गए और अग्रणी शून्य से सूची को आउटपुट करें।

इसके लिए आउटपुट होगा:

[8, 1, 4, 3, 5, 6, 4, 1, 2]

कुछ अन्य परीक्षण मामले:

[0, 4, 1, 2, 0, 1, 2, 4, 0] > [4, 1, 2, 0, 1, 2, 4]
[0, 0, 0, 0, 0, 0] > nothing
[3, 4, 5, 0, 0] > [3, 4, 5]
[6] > [6]

सबसे छोटा कोड जीतता है

code-golf array-manipulation

— Lamaro
स्रोत

क्या केवल गैर-नकारात्मक पूर्णांक हैं? मेरा सुझाव है कि आप स्पष्ट करें या अन्य नंबरों के साथ परीक्षण के मामलों को जोड़ दें

— लुइस मेंडो

1

क्या हम मान सकते हैं कि कम से कम एक अग्रणी और एक अनुगामी 0 होगा?

— DJMcMayhem

4

क्या कुछ नहीं बनता है? मैं कई अलग-अलग चीजों के बारे में सोच सकता हूं जो पर्ल 6 में कुछ भी भिन्नताएं नहीं हैं Nil ()/ [] slip()/ Empty Any {}उनमें से कुछ अपरिभाषित हैं, कुछ परिभाषित लेकिन विलक्षण हैं, कुछ जो अन्य सूचियों में फिसलते हैं जैसे कि वे तत्वों की संख्या में वृद्धि नहीं करते हैं। ( Anyवर्ग / प्रकार और भूमिकाएं जितनी भिन्न हैं, उतनी ही भिन्नताएं भी हैं)

— ब्रैड गिल्बर्ट b2gills

7

क्या यह संयोग है कि 10 से अधिक पूर्णांक नहीं हैं या क्या हम मान सकते हैं कि सभी संख्याएँ एकल-अंक होने जा रही हैं?

— एक सीमन्स

1

क्या हम सूची को एक सीमांकित स्ट्रिंग के रूप में इनपुट / आउटपुट कर सकते हैं? उदाहरण के लिए: "0,4,1,2,0,1,2,4,0" => "4,1,2,0,1,2,4"EDIT: बस कई भाषाओं ने पहले ही ऐसा देखा है।

— Mwr247

25

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

कोड:

t0

स्पष्टीकरण:

t   # Trim off...
 0  #  zero at both sides

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

— अदनान
स्रोत

10

यह काम? चीज़। मुझे लगा कि MATL उत्तर पागल थे।

— Skyl3r

4

wut y no don do jelly

— Addison Crump

बेशक जेली हर दूसरे आदमी को लगभग हर बार

— हरा देती है

क्या जेली का वास्तविक व्यवसायों में उपयोग किया जाता है?

— Chromozorz

यार, मुझे आशा है कि नहीं

— कालेब पॉल

10

जावास्क्रिप्ट (ईएस 6) 43

a=>(f=a=>a.reverse().filter(x=>a|=x))(f(a))

कम गोल्फ वाला

a=>{
  f=a=>a.reverse().filter(x=>a|=x) // reverse and remove leading 0
  // leverage js cast rules: operator | cast operands to integer
  // an array casted to integer is 0 unless the array is made of
  // a single integer value (that is ok for me in this case)
  return f(f(a)) // apply 2 times
}

परीक्षा

F=a=>(f=a=>a.reverse().filter(x=>a|=x))(f(a))

function test(){
  var l=(I.value.match(/\d+/g)||[]).map(x=>+x)
  O.textContent=F(l)
}

test()

#I { width:90%}

<input id=I oninput='test()' value='0 0 1 3 7 11 0 8 23 0 0 0'>
<pre id=O></pre>

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

— edc65
स्रोत

1

अच्छा लगा। f=(a,r=f(a,a))=>r.reverse().filter(x=>a|=x)43 बाइट्स भी है।

— नील

6

सीजेएम, 13 बाइट्स

l~{_{}#>W%}2*

सरणी के साथ इनपुट किया गया।

लंबा संस्करण:

l~             Puts input on the stack and parse as array
  {       }    Code block
   _           Duplicate the first thing on the stack
    {}#        Finds the index of the first non-0 value in the array, puts it on the stack
       >       Slices the array from that index
        W%     Reverses the array
           2*  Does the code block twice in total

— एंजेला जू
स्रोत

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

— फल तोड़ना

5

अजगर, 4 बाइट्स

.sQ0

डेमो:

llama@llama:~$ pyth -c .sQ0
[0, 0, 0, 1, 2, 0, 3, 4, 0, 0, 5, 0, 0, 0, 0]
[1, 2, 0, 3, 4, 0, 0, 5]

पायथrev-doc.txt से :

.s <seq> <any>
    Strip from A maximal prefix and suffix of A consisting of copies of B.

— Doorknob
स्रोत

5

05AB1E , 4 बाइट्स

कोड:

0Û0Ü

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

स्पष्टीकरण:

0Û    # Trim off leading zeroes
  0Ü  # Trim off trailing zeroes

CP-1252 एन्कोडिंग का उपयोग करता है।

— अदनान
स्रोत

5

रेटिना, 12 बाइट्स

^0 ?

)` 0$

अनुगामी लाइनफीड महत्वपूर्ण है।

कुछ बाइट बचाने के लिए @Martin Büttner और @FryAmTheEggman को धन्यवाद ।

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

— andlrc
स्रोत

5

आर, 43 बाइट्स

function(x)x[cummax(x)&rev(cummax(rev(x)))]

या STDIN / STDOUT को पढ़ें / लिखें

x=scan();cat(x[cummax(x)&rev(cummax(rev(x)))])

यह शुरुआत और अंत (उलट) स्ट्रिंग से अधिकतम संचयी पाता है। &ऑपरेटर एक ही आकार के तार्किक एक करने के लिए इन दो वैक्टर धर्मान्तरित के रूप में x, (शून्य हमेशा के लिए परिवर्तित किया जाएगा FALSEऔर करने के लिए सब कुछ TRUE), इस तरह से यह संभव बनाता है से सबसेट तक xमुलाकात की स्थिति के अनुसार।

— डेविड अर्नबर्ग
स्रोत

5

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

t=f.f;f=reverse.dropWhile(<1)

— इति बर-नातान
स्रोत

4

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

#//.{0,a___}|{a___,0}:>{a}&

यह बार-बार प्रतिस्थापन नियम लागू करता है जब तक कि ऐसी कार्रवाई एक नया आउटपुट प्रदान करने में विफल रहती है। 7 बाइट्स ने एलेफल्फा के लिए धन्यवाद बचाया।

पहला नियम शुरुआत में एक शून्य हटाता है; दूसरा नियम सरणी के अंत में एक शून्य हटाता है।

— DavidC
स्रोत

3

#//.{0,a___}|{a___,0}:>{a}&

— एलेफाल्फा

4

05AB1E, 4 बाइट्स

0Û0Ü

मूल रूप से एक ट्रिम के रूप में दिए गए इनपुट के शून्य से पीछे चल रहे प्रमुख ट्रिमिंग।

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

— पॉल पिकार्ड
स्रोत

3

पर्ल, 19 + 1 = 20 बाइट्स

s/^(0 ?)+|( 0)+$//g

-pध्वज की आवश्यकता है :

$ perl -pE's/^(0 )+|( 0)+$//g' <<< '0 0 0 1 2 3 4 5 6 0 0 0'
1 2 3 4 5 6

— andlrc
स्रोत

@ मार्टिनबटनर हालांकि मैं [टिप्पणी जोड़ें] को मारने के बाद उसी के बारे में, अब मुझे सिर्फ यह पता लगाने की जरूरत है कि

— मार्कडाउन

दुष्ट HTML हैक। ;)

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

1

17 + 1 बाइट्स:s/^0 | 0$//&&redo

— केनी

@Kenney यह सुंदर है :-) आपको उत्तर के रूप में पोस्ट करना चाहिए!

— andlrc

धन्यवाद! मेरा मूल भी 19 + 1 बाइट्स था, लेकिन फिर मैंने आपका जवाब देखा जिसने मुझे 2 और शेव करने का विचार दिया, इसलिए यदि आप इसे चाहते हैं तो यह आपका है। Btw, आपका जवाब वास्तव में 18 + 1 है यदि आप ?उदाहरण के रूप में छोड़ देते हैं - लेकिन यह कम नहीं होगा "0"..

— केनी

3

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

Uo\U,o\PTị

यह बिलिन का उपयोग नहीं करता है।

Uo\U            Backward running logical OR
    ,           paired with
     o\         Forward running logical OR
       P        Product
        T       All indices of truthy elements
         ị      Index the input at those values.

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

— lirtosiast
स्रोत

3

पर्ल, 38 बाइट्स

$\.=$_}{$\=~s/^(0\n)*|(0\n)*\n$//gs

के साथ चलाएँ perl -p, (3 बाइट्स के लिए जोड़ा गया -p)।

एसटीडीआईएन पर नंबर स्वीकार करता है, प्रति पंक्ति एक; STDOUT पर नंबर, एक प्रति पंक्ति, एक अच्छी तरह से व्यवहार यूनिक्स उपयोगिता के रूप में चाहिए।

केवल शून्य के रूप में '0' द्वारा दर्शाए गए संख्याओं को ही मानता है; रेगेक्स में कुछ और बाइट्स के साथ अन्य अभ्यावेदन का समर्थन करना संभव होगा।

लंबा संस्करण, अभी भी इसके साथ चलाया जाना है -p:

    # append entire line to output record separator
    $\.=$_
}{
    # replace leading and trailng zeroes in output record separator
    $\ =~ s/^(0\n)*|(0\n)*\n$//gs
    # output record separator will be implicitly printed

विस्तारित संस्करण, -p ध्वज के साथ बातचीत दिखा रहा है:

# implicit while loop added by -p
while (<>) {
    # append line to output record separator
    $\.=$_
}{ # escape the implicit while loop
    # replace leading and traling 
    $\=~s/^(0\n)*|(0\n)*\n$//gs
    # print by default prints $_ followed by
    # the output record separator $\ which contains our answer
    ;print # implicit print added by -p
} # implicit closing brace added by -p

— डेविड मॉरिस
स्रोत

यह मानकर कि आप साथ चल रहे हैं perl -E, -pध्वज को आमतौर पर केवल एक बाइट के रूप में गिना जाता है, क्योंकि उस और उसके बीच केवल एक अतिरिक्त बाइट अलग होती है perl -pE।

— क्रिस

3

अमृत, 77 बाइट्स

import Enum
z=fn x->x==0 end
reverse(drop_while(reverse(drop_while(l,z)),z))

l सरणी है।

संपादित करें: वाह! कॉपी / पास्ता फेल बेशक एक को Enum आयात करना होगा, जो 12 से बाइट की गिनती बढ़ाता है (या Enum.function_name का उपयोग करता है, जो इसे और भी लंबा कर देगा)।

— srecnig
स्रोत

3

विटसी, 13 बाइट्स

Vitsy धीरे-धीरे बेहतर हो रहा है ... (मैं आपके लिए जेली लेकर आ रहा हूं। ಠ_ getting)

1mr1m
D)[X1m]

यह स्टैक पर सरणी के साथ बाहर निकलता है। पठनीयता के लिए, TryItOnline! लिंक जो मैंने स्पष्टीकरण के नीचे प्रदान किया है, एक स्वरूपित सूची का उत्पादन करेगा।

स्पष्टीकरण:

1mr1m
1m      Do the second line of code.
  r     Reverse the stack.
   1m   I'ma let you figure this one out. ;)

D)[X1m]
D       Duplicate the top item of the stack.
 )[   ] If the top item of the stack is zero, do the stuff in brackets.
   X    Remove the top item of the stack.
    1m  Execute the second line of code.

ध्यान दें कि यह अनुचित रूप से बड़े इनपुट के लिए एक StackOverflowException को फेंक देगा।

TryItOnline!

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

2

विटसी को किसी दिन जेली मिलेगी।

— कॉनर ओ'ब्रायन

— ईओएल

3

आर, 39 बाइट्स

function(x)x[min(i<-which(x>0)):max(i)]

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

— rturnbull
स्रोत

3

MATL , 9 बाइट्स

2:"PtYsg)

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

व्याख्या

2:"     % For loop (do the following twice)
  P     %   Flip array. Implicitly asks for input the first time
  t     %   Duplicate
  Ys    %   Cumulative sum
  g     %   Convert to logical index
  )     %   Apply index
        % Implicitly end for
        % Implicitly display stack contents

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

2

दिल्लोग एपीएल, 15 बाइट्स

{⌽⍵↓⍨+/0=+\⍵}⍣2

               ⍣2     Apply this function twice:
{             }       Monadic function:
           +\⍵        Calculate the running sum.
       +/0=           Compare to zero and sum. Number of leading zeroes.
   ⍵↓⍨               Drop the first that many elements from the array.
 ⌽                   Reverse the result.

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

— lirtosiast
स्रोत

कैसे के बारे में {⌽⍵/⍨×+\⍵}⍣2?

— lstefano

2

रूबी, 49 44 बाइट्स

->a{eval ?a+'.drop_while{|i|i<1}.reverse'*2}

पूरी तरह से अलग विधि के साथ 5 बाइट्स को काटने के लिए मैनटवर्क का धन्यवाद !

यह मात्र 0 dropके पहले तत्व का है, whileयह सरणी को उलटता है, दोहराता है, और अंत में इसे उचित क्रम पर वापस करने के लिए सरणी को उलट देता है।

— Doorknob
स्रोत

आउच। अब भी एक .drop_while()आधारित समाधान कम होगा (यदि 2 कार्यों का उपयोग किया जाता है):f=->a{a.drop_while{|i|i<1}.reverse};->a{f[f[a]]}

— मैनटवर्क

रवींद्र। 2 कार्यों के लिए कोई ज़रूरत नहीं है, बस कुछ evalकुरूपता ->a{eval ?a+'.drop_while{|i|i<1}.reverse'*2}:।

— मैनटवर्क

@manatwork मुझे यकीन नहीं है कि मैंने क्यों नहीं सोचा <1, वैसे भी। धन्यवाद!

— दरवाज़े

2

विम 16 कीस्ट्रोक्स

i<input><esc>?[1-9]<enter>lD0d/<up><enter>

इनपुट के बीच उपयोगकर्ता द्वारा टाइप किया जा रहा है iऔर escहै, और एक कीस्ट्रोक के रूप में नहीं गिना जाता। यह मानता है कि कम से कम एक अग्रणी और एक अनुगामी शून्य होगा। यदि यह मान्य धारणा नहीं है, तो हम इस थोड़े लंबे संस्करण का उपयोग कर सकते हैं: (18 कीस्ट्रोक्स)

i <input> <esc>?[1-9]<enter>lD0d/<up><enter>

— DJMcMayhem
स्रोत

1

मुझे नहीं लगता कि उपयोगकर्ता को नंबर ( iऔर <esc>) इनपुट करने की अनुमति देने के लिए आपको कोड शामिल करने की आवश्यकता है । विम गोल्फ में गोल्फर इनपुट के साथ पहले से ही बफर और कर्सर को ऊपरी बाएं कोने में लोड करता है, लेकिन उपयोगकर्ता को भी बचाना और बाहर निकलना होता है ( ZZयह आमतौर पर सबसे तेज़ तरीका है)। तब आप कुछ ऐसा कर सकते थे d[1-9]<enter>$NlDZZ(13 कीस्ट्रोक्स)। नोट N/ के nबजाय/<up><enter>

— daniero

2

ईएस 6, 51 बाइट्स

f=a=>a.map(x=>x?t=++i:f<i++||++f,f=i=0)&&a.slice(f,t)

tपिछले गैर-शून्य मान के बाद सूचकांक पर सेट किया गया है, जबकि fवृद्धि हुई है जब तक कि केवल शून्य अब तक देखा गया है।

— नील
स्रोत

2

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

{.[.grep(?*):k.minmax]}
{.[minmax .grep(?*):k]}

उपयोग:

# replace the built-in trim subroutine
# with this one in the current lexical scope
my &trim = {.[.grep(?*):k.minmax]}

say trim [0, 0, 0, 8, 1, 4, 3, 5, 6, 4, 1, 2, 0, 0, 0, 0];
# (8 1 4 3 5 6 4 1 2)
say trim [0, 4, 1, 2, 0, 1, 2, 4, 0];
# (4 1 2 0 1 2 4)
say trim [0, 0, 0, 0, 0, 0];
# ()
say trim [3, 4, 5, 0, 0];
# (3 4 5)
say trim [6];
# (6)

— ब्रैड गिल्बर्ट b2gills
स्रोत

2

रेटिना, 11 बाइट्स

+`^0 ?| 0$
<empty>

काफी सरल। लाइन के आरंभ और अंत में पुन: शून्य को बदल देता है।

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

— मामा फन रोल
स्रोत

2

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

a=>a.join(a="").replace(/(^0+|0+$)/g,a).split(a)

aसरणी कहां है

— user2428118
स्रोत

4

मुझे लगता है कि आपको इनपुट लेने के लिए एक अनाम फ़ंक्शन बनाने की आवश्यकता है a=>a.join(a="")...:।

— andlrc

2

यह केवल पूर्णांक को ठीक से संभालता है जब वे एकल अंक हैं

— 23

@ देव-नल डन।

— user2428118

फिर भी बहु-अंक पूर्णांकों के लिए गलत लौटना। [14]वापस आ जाएगा [1, 4]।

— Mwr247

वास्तव में, मैं अभी भी (और हूँ) इस टिप्पणी के उत्तर की प्रतीक्षा कर रहा था । वैसे भी, मैं दुर्भाग्य से एक ही तकनीक का उपयोग करने का एक तरीका नहीं देखता, जो मैंने अपने उत्तर के लिए उपयोग की है उसी तकनीक का उपयोग करके और मुझे नहीं लगता कि मैं इस उत्तर को वैसे भी हरा पाऊंगा । मैं कोशिश कर सकता हूं जब मेरे पास समय हो, हालांकि।

— user2428118

2

पायथन, 84 वर्ण

def t(A):
 if set(A)<={0}:return[]
 for i in(0,-1):
  while A[i]==0:del A[i]
 return A

— pafcjo
स्रोत

आप कर सकते हैंfor i in-1,0:

— mbomb007

मैं 86 बाइट्स गिनता हूं।

— आउटगॉल्फ

2

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

a=>a.replace(/^(0 ?)*|( 0)*$/g,'')

इनपुट और आउटपुट एक अंतरिक्ष-सीमांकित सूची के रूप में हैं, जैसे "0 4 1 2 0 1 2 4 0"।

— Mwr247
स्रोत

2

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

a=>/^(0,)*(.*?)(,0)*$/.exec(a.join())[2]

— शॉन एच
स्रोत

2

PHP, 56 54 52 बाइट्स

Windows-1252 एन्कोडिंग का उपयोग करता है

स्ट्रिंग आधारित समाधान

<?=preg_replace(~ÜÒ×ßÏÖÔƒ×ßÏÖÔÛÜ,"",join($argv,~ß));

इस तरह से चलाएं:

echo '<?=preg_replace(~ÜÒ×ßÏÖÔƒ×ßÏÖÔÛÜ,"",join($argv,~ß));' | php -- 0 0 123 234 0 500 0 0 2>/dev/null;echo

यदि आपका टर्मिनल UTF-8 में सेट है, तो यह वही है:

echo '<?=preg_replace("#-( 0)+|( 0)+$#","",join($argv," "));' | php -- 0 0 123 234 0 500 0 0 2>/dev/null;echo

बदलाव

तार की उपेक्षा और स्ट्रिंग सीमांकक को छोड़ने के द्वारा 2 बाइट्स बचाए
शॉर्ट प्रिंट टैग का उपयोग करके 2 बाइट्स बचाए

— aross
स्रोत

1

क्या आप कृपया ASCII समाधान प्रदान कर सकते हैं। इसे कोई नहीं पढ़ सकता है!

— टाइटस

1

@ टिट्स ज़रूर हालांकि, वहाँ बहुत सारे अपठनीय esolangs .... यह ऐसा नहीं है कि मेरा जवाब घर पर सही नहीं लगता है।

— सकल

शामिल होने के पहले पैरामीटर के रूप में एक सरणी?

— जार्ज ह्यूल्समैन 14

1

@ जॉर्गहल्सरमन यप। इसे दूसरे तरीके से प्रलेखित किया गया है लेकिन यह दोनों को स्वीकार करता है।

— पार

आप सही हैं, मुझे इसका एहसास नहीं हुआ है

— Jörg Hülsermann

2

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

def f(a):
 for i in(0,-1):
  while a and a[i]==0:a.pop(i)
 return a

— SumnerHayes
स्रोत

आप दूसरी पंक्ति में अपने टपल से पहले स्थान को हटा सकते हैं।

— ज़च गेट्स

आप कर सकते हैंfor i in-1,0:

— mbomb007 14

इसके अलावा, आप अपनी बाइट्स को पुनः प्राप्त करना चाहते हैं। मेरी गिनती 67 है। आप के [space][space]whileसाथ भी बदल सकते हैं [tab]while। और ==0हो सकता है <1। mothereff.in/…

— mbomb007 15

मैं 67 बाइट्स गिनता हूं।

— आउटगॉल्फ

1

पॉवरशेल, 49 बाइट्स

($args[0]-join',').trim(',0').trim('0,')-split','

इनपुट बनाता है $args[0]और -joinउन्हें एक स्ट्रिंग बनाने के लिए कॉमा के साथ मिलाता है। फिर हम .Trim()पहले ट्रेलिंग और फिर अग्रणी शून्य और अल्पविराम को निकालने के लिए दो बार फ़ंक्शन का उपयोग करते हैं । हम फिर -splitएक सरणी में वापस अल्पविराम पर स्ट्रिंग करते हैं।

वैकल्पिक संस्करण, PowerShell का उपयोग किए बिना
, 81 बाइट्स

function f{param($a)$a=$a|%{if($_-or$b){$b=1;$_}};$a[$a.Count..0]}
f(f($args[0]))

चूंकि PowerShell में सरणियों को ट्रिम करने का कोई फ़ंक्शन नहीं है, इसलिए हम एक नए फ़ंक्शन को परिभाषित करते हैं fजो हमारे लिए इसका आधा हिस्सा करेगा। फ़ंक्शन $aइनपुट के रूप में लेता है , फिर प्रत्येक आइटम के माध्यम से फ़ॉरच लूप के माध्यम से लूप करता है |%{...}। प्रत्येक पुनरावृत्ति, हम के लिए एक सशर्त जाँच करते हैं $_ -or $b। चूंकि गैर-शून्य पूर्णांक $nullसत्य होते हैं, लेकिन यह गलत है (और $b, पहले से परिभाषित नहीं किया जा रहा है, जैसा कि शुरू होता है $null), यह केवल $trueएक बार जब हम सरणी में हमारे पहले गैर-शून्य तत्व को हिट करते हैं , तो इसका मूल्यांकन करेंगे । हम तब पाइपलाइन पर $b=1वर्तमान मूल्य सेट और जोड़ते हैं $_। तब हम इनपुट सरणी के अंत के माध्यम से जारी रखेंगे, मध्य में शून्य और आउटपुट पर जोड़ा जा रहा है, क्योंकि हमने $bसत्य निर्धारित किया है ।

हम सभी लूप के परिणामों को वापस इनकैप्सुलेट और स्टोर करते हैं $a। फिर, हम $aरिवर्स ऑर्डर में इंडेक्स करते हैं (यानी, एरे को उलटते हुए), जिसे पाइप लाइन पर छोड़ दिया जाता है और इस प्रकार फ़ंक्शन का रिटर्न वैल्यू होता है।

हम $args[0]प्रोग्राम को इनपुट पर दो बार प्रोग्राम को सामने से "ट्रिम" करने के लिए कहते हैं, फिर सामने फिर से (जो पीछे की तरफ है, क्योंकि हमने उलटा किया है)। आदेश संरक्षित है क्योंकि हम दो बार उलट रहे हैं।

यह संस्करण सभी शून्य के एक इनपुट ऐरे के लिए नियमों के साथ थोड़ा ढीला खेलता है , लेकिन चूंकि STDERR को स्वीकार करने की प्रथा को स्वीकार नहीं किया जाता है, इसलिए प्रोग्राम दो (क्रिया) Cannot index into a null arrayत्रुटियों को _{(PowerShell के समतुल्य)} STDERR और फिर आउटपुट कुछ भी नहीं करेगा।

— AdmBorkBork
स्रोत

अग्रणी और अनुगामी शून्य निकालें

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

जावास्क्रिप्ट (ईएस 6) 43

सीजेएम, 13 बाइट्स

अजगर, 4 बाइट्स

05AB1E , 4 बाइट्स

रेटिना, 12 बाइट्स

आर, 43 बाइट्स

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

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

05AB1E, 4 बाइट्स

पर्ल, 19 + 1 = 20 बाइट्स

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

पर्ल, 38 बाइट्स

अमृत, 77 बाइट्स

विटसी, 13 बाइट्स

आर, 39 बाइट्स

MATL , 9 बाइट्स

व्याख्या

दिल्लोग एपीएल, 15 बाइट्स

रूबी, 49 44 बाइट्स

विम 16 कीस्ट्रोक्स

ईएस 6, 51 बाइट्स

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

उपयोग:

रेटिना, 11 बाइट्स

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

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

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

PHP, 56 54 52 बाइट्स

बदलाव

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

पॉवरशेल, 49 बाइट्स