ढेर लगाना

Question

मुझे विश्वास नहीं हो रहा है कि हमारे पास यह पहले से नहीं है .. यह प्रोग्रामिंग में सबसे महत्वपूर्ण डेटा-संरचनाओं में से एक है, फिर भी इसे कोड-गोल्फ में लागू करने के लिए अभी भी काफी सरल है :

चुनौती

आपका कार्य एक स्टैक को लागू करना है जो पुश और पॉपिंग नंबर की अनुमति देता है, आपके कार्यान्वयन का परीक्षण करने और I / O को सरल रखने के लिए हम निम्नलिखित सेटअप का उपयोग करेंगे:

• इनपुट गैर-नकारात्मक पूर्णांक की एक सूची होगी

प्रत्येक पॉजिटिव पूर्णांक एक इंगित करता है और प्रत्येक एक दर्शाता है - शीर्ष तत्व को है।पुश ( n ) 0 $n$$\texttt{push(}n\texttt{)}$$0$$\texttt{pop()}$

• आउटपुट परिणामी स्टैक होगा

उदाहरण

उदाहरण के लिए यदि हमें दिया गया है :$[12,3,0,101,11,1,0,0,14,0,28]$

$$\begin{aligned} & 12 & [12] \\ & 3 & [3,12] \\ & 0 & [12] \\ & 101 & [101,12] \\ & 11 & [11,101,12] \\ & 1 & [1,11,101,12] \\ & 0 & [11,101,12] \\ & 0 & [101,12] \\ & 14 & [14,101,12] \\ & 0 & [101,12] \\ & 28 & [28,101,12] \end{aligned}$$

आउटपुट होगा:$[28,101,12]$

नियम

• इनपुट किसी भी डिफ़ॉल्ट I / O प्रारूप में गैर-नकारात्मक पूर्णांक की एक सूची होगी
  • पूर्णांक की एक धारा के अंत को दर्शाने के लिए आप एक नकारात्मक पूर्णांक का उपयोग कर सकते हैं
• आउटपुट परिणामी स्टैक की एक सूची / मैट्रिक्स / .. होगा
  • आपकी पसंद जहां शीर्ष तत्व होगी (शुरुआत या अंत में), आउटपुट को लगातार होना चाहिए
  • आउटपुट लचीला है (उदाहरण के लिए, नई-लाइनों द्वारा अलग किए गए पूर्णांक ठीक होंगे), केवल एक चीज जो ऑर्डर करती है
  • स्टैक के निचले हिस्से को सूचित करने के लिए आप एक नकारात्मक पूर्णांक का उपयोग कर सकते हैं
• आप गारंटी देते हैं कि स्टैक खाली होने पर कभी नहीं होगा$0$

उदाहरण

[] -> []
[1] -> [1]
[1,0,2] -> [2]
[4,0,1,12] -> [12,1]
[8,3,1,2,3] -> [3,2,1,3,8]
[1,3,7,0,0,0] -> []
[13,0,13,10,1,0,1005,5,0,0,0] -> [13]
[12,3,0,101,11,1,0,0,14,0,28] -> [28,101,12]

Comments

यह ध्यान दिया जाना चाहिए कि, शर्तों को देखते हुए, किसी को वास्तव में स्टैक को लागू करने की आवश्यकता नहीं है।

— जेफ जेटलिन

यदि आप चाहते थे कि कोई वास्तव में स्टैक को लागू करे, तो आपको सैंडबॉक्स में कुछ डालने की कोशिश करनी पड़ सकती है।

— mbomb007

@ mbomb007: दोनों की अनुमति है: "अपनी पसंद जहां शीर्ष तत्व (शुरुआत या अंत में) हो जाएगा"

— ბიმო

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

— ।

@ OM @ क्योंकि इनपुट स्टैक / लिस्ट / एरे की तरह काफी सा दिखता है। अब, पूरी चुनौती मूल रूप से शून्य के बाद किसी भी संख्या को हटा देती है।

— mbomb007

Answer 1

MATL , 6 बाइट्स

"@?@}x

इनपुट संख्याओं की एक पंक्ति वेक्टर है।

अंतिम स्टैक को ऊपर की ओर दिखाया गया है, जिसमें सबसे हालिया तत्व नीचे है।

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

व्याख्या

"         % For each element in the input (implicit)
  @       %   Push current element
  ?       %   If non-zero (this consumes the current element)
    @     %     Push current element again
  }       %   Else
    x     %     Delete most recent element
          %   End (implicit)
          % End (implicit)
          % Display (implicit)

Answer 2

जावा (JDK 10) , 42 बाइट्स

चूंकि "[] आउटपुट लचीला है [...], केवल एक चीज जो मायने रखती है वह है ऑर्डर", यह इनपुट ऐरे को एक 0ऐन्टिमेंटेड एरे में बदलता है। उदाहरण: [1,0,2]वापस आ जाएगी [2,0,2]जो के रूप में व्याख्या की जा रही है = ।[2,0,2][2]

a->{int s=0;for(int v:a)a[v>0?s++:--s]=v;}

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

पिछला संस्करण:

जावा (JDK 10) , 60 बाइट्स

l->{for(int i;(i=l.indexOf(0))>0;l.remove(i))l.remove(--i);}

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

क्रेडिट:

• OOBalance के लिए -1 बाइट धन्यवाद

यदि मैं त्रुटियों के साथ कार्यक्रम को समाप्त कर सकता हूं: 55 बाइट्स

(हालांकि सब कुछ ठीक से संशोधित किया गया है)

l->{for(int i;;l.remove(--i))l.remove(i=l.indexOf(0));}

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

Comments

यह बल्कि प्रभावशाली है। आप 1 बाइट का उपयोग कर खो सकते हैं >0क्योंकि सूची की शुरुआत में कभी भी शून्य नहीं होगा (जो स्टैक के शीर्ष पर होगा -1)।

— OOBalance

@Oobalance वास्तव में, मैंने इसके बारे में नहीं सोचा था। धन्यवाद!

— ओलिवियर ग्राएगोयर

Answer 3

सेड, 17 ​​बाइट्स

:;s/[0-9]\+,0//;t

-3 बाइट्स @ OMᗺ के लिए धन्यवाद, -1 @eggyal के लिए धन्यवाद

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

स्टड से इनपुट लेता है, जैसे:

echo '[12,3,0,101,11,1,0,0,14,0,28]' | sed ':;s/[0-9]\+,0,//;t'

स्टैक को रिवर्स में आउटपुट करता है:

[12,101,28]

अगर मेरे स्थानीय sedस्वाभाविक रूप से चरित्र वर्गों की तरह समझ में आते हैं \d, तो दो बाइट्स से छोटे हो सकते हैं , लेकिन यह किसी कारण से नहीं होता है।

Comments

PPCG में आपका स्वागत है! अच्छा था, मेरा लंबा था (विभिन्न इनपुट प्रारूप का उपयोग करके) .. Btw। आप केवल 1 का उपयोग करने के बाद से एक खाली लेबल का उपयोग कर सकते हैं और जब से आप प्रक्रिया को पुनरावृत्त करते हैं, gनिरर्थक है - आपको 4 बाइट्स बचा रहा है: ऑनलाइन प्रयास करें!

— ბიმო

जी बेमानी नहीं है! यह सबसे खराब स्थिति को रनटाइम जटिलता बनाता है जो पॉप की संख्या के बजाय अनुक्रमिक चबूतरे की गहराई पर निर्भर करता है! कोड गोल्फ में वह दक्षता मायने नहीं रखती है :)

— Tacroy

आपका अंतिम वाक्य अतिरेक के बारे में प्रश्न का उत्तर देता है: P Btw। आपने बाइट्स कैसे गिने? मुझे 18 मिलते हैं, शायद आपने अंत में एक नई-लाइन शामिल की है या कुछ और।

— ბიმო

हाँ, यह एक नई लाइन थी।

— टैक्रॉय

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

— इग्गीलाल

Answer 4

पॉवरशेल , 46 41 40 बाइट्स

$args|%{$x,$a=&({1,$_+$a},{$a})[!$_]};$a

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

विभाजन के माध्यम से इनपुट लेता है, जैसे $z=@(12,3,0,101,11,1,0,0,14,0,28); .\implement-stack.ps1 @z, जो TIO पर अलग-अलग तर्क के रूप में प्रकट होता है।

$args|%{$x,$a=&({1,$_+$a},{$a})[!$_]};$a    # Full program
$args                                       # Take input via splatting
     |%{                            };      # Loop through each item
              &(              )[!$_]        # Pseudo-ternary, if input is 0 this is 1
        $x,$a=            {$a}              # ... which will pop the first item into $x
           $a=  { ,$_+$a}                   # Else, we append the first item
        $x   =   1                          # ... and drop a dummy value into $x
                                      $a    # Leave $a on pipeline; implicit output

-5 बाइट्स mazzy के लिए धन्यवाद।
-1 बाइट स्वैपिंग $_टू1

Comments

क्या एक बवंडर 3 बाइट्स को बचाता है $agrs? :)

— माज़ी

-2 बाइट्स $args|%{$x,$a=&({$_,$_+$a},{$a})[!$_]};$a?

— माज़ी जूल 27'18

@mazzy हाँ, और हमने सिर्फ छींटाकशी के बारे में बात की थी! मैं पहले से ही भूल गया! बहुत ज़ोर से हँसते हुए धन्यवाद!

— AdmBorkBork

बिखरना नहीं होगा .\implement-stack.ps1 @z(नहीं $z), अन्यथा आप पहले / केवल तर्क के रूप में एक सरणी पास कर रहे हैं

— गुलाबीफ्लक्सएक्स

@ pinkfloydx33 हां। मेरी ओर से टाइपो।

— AdmBorkBork

Answer 5

सी (जीसीसी) , 62 60 56 55 बाइट्स

-2 -6 बाइट्स l4m2 के लिए धन्यवाद

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

-1 समाप्त सरणियों की अनुमत धारणा का उपयोग करता है। f()पूरी तरह से घाव तक, और फिर सूची के माध्यम से पीछे हटता है। rकिसी चीज़ को प्रिंट करने से पहले कितने नंबर को छोड़ना है, इस पर नज़र रखें। बढ़ता है यदि वर्तमान आइटम 0 है, अन्यथा घट जाती है। यदि 0 है, तो हमें त्यागने की आवश्यकता नहीं है, और संख्या को प्रिंट कर सकते हैं।

r;f(int*l){~*l?f(l+1),*l?r?r--:printf("%d ",*l):r++:0;}

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

Comments

f(l)int*l;=> f(int*l)?

— l4m2

@ l4m2 आह, जयकार! संभवतः पहले का अवशेष, अधिक चर-चर दिन।

— गैस्ट्रोपनर

r=0बेकार लगता है

— l4m2

@ l4m2 ऐ, अच्छी पकड़।

— गैस्ट्रोपनर

Answer 6

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

foldl(#)[]
(_:s)#0=s
s#n=n:s

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

Comments

मुख्य समारोह का नाम कैसे दिया जाता है? मुझे नहीं पता, इसे कैसे चलाना है)

— евгений Новиков

@ :ВгенийНовиков: कोड चलाने के तरीके के एक उदाहरण के लिए "ऑनलाइन प्रयास करें" लिंक देखें।

— नीम

Answer 7

आर , 45 बाइट्स

o={};for(e in scan())o="if"(e,c(e,o),o[-1]);o

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

• -4 बाइट @ @iuseppe के लिए धन्यवाद

Comments

48 बाइट्स - गाली देने Fसे आपको 48 बाइट्स भी मिलेंगे लेकिन यह क्लीनर imho है

— Giuseppe

मैं नहीं जानता कि मैं कैसे-अगर उलटा याद किया: facepalm: ... धन्यवाद!

— डाइजेक्सिल

45 बाइट्स

— Giuseppe

A R+pryrऔर Reduceसमाधान 44 बाइट्स है

— JayCe

@ जय: ईमानदार होने के लिए, मैं इसे "बेस-आर" समाधान रखना पसंद करता हूं ... लेकिन इसे अपने स्वयं के उत्तर के रूप में पोस्ट करने के लिए स्वतंत्र महसूस करता हूं! ;)

— digEmAll

Answer 8

पायथन 2 , 59 57 51 बाइट्स

s=[]
for x in input():s=(s+[x],s[:-1])[x<1]
print s

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

Answer 9

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

ṣ0Ṗ;¥/

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

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

ṣ0Ṗ;¥/  Main link. Argument: A (array)

ṣ0      Split A at zeroes.
    ¥/  Left-reduce the resulting 2D array by this dyadic chain:
  Ṗ       Pop; discard the last element of the left argument.
   ;      Concatenate the result with the right argument.

Comments

अगर तीन लगातार शून्य हैं तो क्या यह तीन चबूतरे का अनुकरण करेगा?

— WGroleau

हाँ। [1,3,7,0,0,0], उदाहरण के लिए, विभाजित हो जाता है [[1,3,7],[],[],[]], और बाएं सरणी के तत्व पर बाएं-कम पॉप के प्रत्येक चरण।

— डेनिस

Answer 10

ब्रेन-फ्लैक , 40 36 बाइट्स

([]){{}{({}<>)<>}([]){{}<>}{}([])}<>

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

-4 बाइट्स के लिए @Nitrodon का धन्यवाद।

चूंकि ब्रेन-फ्लैक पहले से ही स्टैक्स का उपयोग करता है, यह ब्रेन-फ्लैक के लिए एक अच्छी पहेली है।

([]){   while items on stack
    {}      pop stack count
    {       if top element is non-zero
        ({}<>)<> push it on the other stack
    }
    if we're here the stack is either empty or there's a 0 on the stack

    ([])    so, count the stack again
    {{}<>{}<>} if there are items left on the stack, pop the stack count and the last item of the other stack
    {} pop the zero or the stack count
    ([]) count the stack again for next round
}
<>  go to the output stack

Comments

इस विशेष मामले में, {{}<>{}<>}को छोटा किया जा सकता है {{}<>}।

— नाइट्रोडॉन

@Nitrodon धन्यवाद। क्या आप बता सकते हैं, यह अभी भी क्यों काम करता है? यह लूप में इनपुट स्टैक पर वापस स्विच नहीं करता है।

— डोरियन

आउटपुट स्टैक के शीर्ष को नॉनजरो होने की गारंटी है, इसलिए छोटा लूप 0 या 2 बार निष्पादित होता है।

— नाइट्रोडॉन

Answer 11

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 28 बाइट्स

#//.{a___,b_,0,c___}:>{a,c}&

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

Comments

(यह केवल इसलिए काम करता है क्योंकि "डिफ़ॉल्ट पहले के पैटर्न कम से कम क्रम से मेल खाता है" , इसलिए यह सुनिश्चित करने की कोई आवश्यकता नहीं है कि b

— नॉनज़रो है

@ user202729 हां। मैथेमेटिका का पैटर्न-मिलान गैर-लालची है, इसलिए यह सबसे कम संभव a___पहले से मेल खाने की कोशिश करता है । एक कोशिश करके देख सकते हैं ReplaceList[#, {a___, b_, 0, c___} :> {a, c}] &। एक संबंधित नोट पर, StringReplaceवास्तव में लालची है, इसलिए यह सबमिशन StringReplace(पैटर्न जैसे a___~~b_~~"0"~~c___) के साथ काम नहीं करेगा

— जुंगवान मिन

Answer 12

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

s=[]
for x in input():s=([x]+s)[2*0**x:]
print s

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

Comments

कोई भी मौका आप बता सकते हैं कि यह कैसे काम करता है? मैं पिछले आधे घंटे से इसे काम करने की कोशिश कर रहा हूँ! निश्चित रूप 2*0**xसे हमेशा होने वाला है 0। मुझे स्पष्ट रूप से कुछ याद आ रहा है।

— ElPedro

@ElPedro यह शून्य नहीं है x=0, जब यह किस स्थिति में है

— xnor

ओह, अब समझा तुम्हारा क्या मतलब है। लगता है कि मैं बहुत मुश्किल लग रहा था और स्पष्ट याद आ रही थी! धन्यवाद और शानदार जवाब।

— ElPedro

Answer 13

व्हॉट्सएप , 89 बाइट्स

[N
S S N
_Create_Label_LOOP_1][S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve][S N
S _Duplicate_input][N
T   T   S 
_If_neg_Jump_to_Label_EXIT][S N
S _Duplicate_input][N
T   S T N
_If_0_Jump_to_Label_DROP][N
S N
N
_Jump_to_Label_LOOP_1][N
S S S N
_Create_Label_EXIT][S N
N
_Discard_top][N
S S S S N
_Create_Label_LOOP_2][T N
S T _Print_as_integer][S S S T  S T S N
_Push_10_newline][T N
S S _Print_as_character][N
S T S S N
_Jump_to_Label_LOOP_2][N
S S T   N
_Create_Label_DROP][S N
N
_Discard_top][S N
N
_Discard_top][N
S N
N
_Jump_to_Label_LOOP_1]

पत्र S(स्थान), T(टैब), और N(नई-पंक्ति) केवल हाइलाइटिंग के रूप में जोड़े गए।
[..._some_action]केवल स्पष्टीकरण के रूप में जोड़ा गया।

इनपुट-सूची नई-लाइन -1को इंगित करने के लिए अलग किया जाता है ताकि हम इनपुट के साथ काम कर सकें।

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

छद्म कोड में स्पष्टीकरण:

Start LOOP_1:
  Integer i = STDIN as integer
  If(i is negative):
    Call function EXIT
  If(i is 0):
    Call function DROP
  Go to next iteration of LOOP_1

function EXIT:
  Start LOOP_2:
    Pop and print top as integer
    Print newline
    Go to next iteration of LOOP_2

function DROP:
  Drop the top of the stack
  Go to next iteration of LOOP_1

Answer 14

अजगर 2 , 60 59 57 56 बाइट्स

l=input()
while 0in l:i=l.index(0);l[i-1:i+1]=[]
print l

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

---

बचाया:

• -1 बाइट, पुशकिन के लिए धन्यवाद

Comments

आप के बीच की जगह को निकाल कर एक बाइट को बचा सकता है 0औरin

— Pushkin

10K पर बधाई

— ElPedro

Answer 15

जावास्क्रिप्ट, 40 बाइट्स

रिवर्स ऑर्डर में आउटपुट।

a=>a.map(x=>x?o.push(x):o.pop(),o=[])&&o

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

1 बाइट ने हरमन एल को धन्यवाद दिया ।

Comments

a=>a.map(x=>x?o.push(x):o.pop(),o=[])&&oएक बाइट कम है

— हरमन एल

@ हर्मनल: डी'ओह! निश्चित रूप से यह है! धन्यवाद। (un)shiftमैं धब्बेदार उत्पादन उलट हो सकता है इससे पहले उपयोग कर रहा था।

— झबरा

यह काम करता है क्योंकि oकॉलबैक में संदर्भित होने के बाद इसे दूसरे तर्क में परिभाषित किया गया है।

— मट्ठा

Answer 16

05AB1E , 9 बाइट्स

vy>i¨ëy)˜

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

स्पष्टीकरण:

v        # For-each of the items in the input-list:
 y>i     #  If the current item is 0:
  ¨      #   Pop the top item of the list
 ë       #  Else:
  y      #   Push the current item to the stack
   )     #   Wrap the entire stack into a list
         #    i.e. 12 → [12]
         #    i.e. [12] and 3 → [[12], 3]
    ˜    #   Flatten the stack
         #    i.e. [[12], 3] → [12, 3]
         # (and output the list implicitly after the loop)

---

9 बाइट्स वैकल्पिक:

vy_i\ëy])

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

स्पष्टीकरण:

v        # For-each of the items in the input-list:
 y_i     #  If the current item is 0:
  \      #   Discard top item of the stack
 ë       #  Else:
  y      #   Push the current item to the stack
]        # Close both the if-else and for-each (short for `}}`)
 )       # Wrap the entire stack into a list (and output implicitly)

पुनश्च: यदि आउटपुट को चुनौती के विवरण में परीक्षण के मामलों से मिलान करने के लिए उलट दिया जाना चाहिए, तो हम Rदूसरे संस्करण (इसलिए 10 बाइट्स ) में एक अनुगामी जोड़ सकते हैं , जो सूची को उलट देता है। इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

Answer 17

रेटिना 0.8.2 , 18 बाइट्स

^
,
+1`,\d+,0

^,

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

^
,

एक अतिरिक्त उपसर्ग ,।

+1`,\d+,0

सभी पॉप ऑपरेशन को प्रोसेस करें।

^,

,यदि यह अभी भी है तो इसे हटा दें ।

संख्या को उलटने से अतिरिक्त 8 बाइट खर्च होंगे:

O^$`\d+

Comments

जो बस <number>, 0कुछ नहीं द्वारा सभी सबलिस्ट को बदल देता है ।

— user202729

Answer 18

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

->a{b=[];a.map{|x|x>0?b<<x:b.pop};b}

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

अनाम लम्बा। रिवर्स ऑर्डर में आउटपुट।

Answer 19

ब्रेन-फ्लैक , 36 बाइट्स

([]){{}{(({}<>))(<>)}{}<>{}<>([])}<>

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

#Let's call the two stacks in and out

([]){{}                      ([])}    # while not in.empty()
       {        (  )}{}               # if in.peek() != 0
        (({}<>)) <>                   # a = in.pop; out.push(a); out.push(a)
                       <>{}<>         # out.pop()
                                  <>  # switch to out to be printed

Answer 20

ब्रेन-फ्लैक , 32 बाइट्स

([]){{}{({}<>)<>}{}<>{}<>([])}<>

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

-1सरणी के अंत को सूचित करने के लिए उपयोग करता है (लेकिन कोई भी संख्या वास्तव में करेगी)।

Answer 21

वी , 10 बाइट्स

ò/ 0⏎b2dw0

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

व्याख्या

ò           " run the following, until an error occurs
 / 0⏎       " | goto next zero with space in front (errors if none)
     b      " | jump one word back (to the beginning of element to pop)
      2     " | twice (element & zero itself)
       dw   " | | delete word
         0  " | goto beginning of line

---

विम , 16 बाइट्स में बराबर

qq/ 0⏎b2dw0@qq@q

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

व्याख्या

बहुत अधिक एक ही है, एक मैक्रो रिकॉर्डिंग qऔर इसे फिर से कॉल करने के अलावा:

qq                " record macro q
  / 0⏎b2dw0       " same as in V
           @q     " recursively call q (aborts on error)
             q    " quit recording
              @q  " execute the macro q

Answer 22

जावा 10, 75 72 बाइट्स

n->{var s="";for(int i:n)s=(s+","+i).replaceAll(",\\d+,0","");return s;}

एक अल्पविराम द्वारा अलग किए गए आउटपुट। स्टैक के ऊपर अंतिम है। इसे यहाँ ऑनलाइन आज़माएँ ।

2 बाइट गोल्फिंग के लिए ओलिवियर ग्रेजायर को धन्यवाद ।

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

Ungolfed:

n -> { // lambda taking an integer array as argument and returning a String
    var s = ""; // we'll be using a String to implement and output the stack
    for(int i : n) // loop through the array
        s = (s + "," + i) // append the next number
               .replaceAll(",\\d+,0", ""); // remove any number followed by a zero
    return s; // output the resulting stack
}

Comments

स्ट्रिंग्स के साथ अच्छा दृष्टिकोण। मेरे वास्तविक Stackअनुभव के साथ मेरे भोले दृष्टिकोण से बेहतर है । मुझ से +1।

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

n->{var s="";for(int i:n)s=(s+","+i).replaceAll(",\\d+,0$","");return s;}(73 बाइट्स), लेकिन ,पहले नंबरों को रखता है , बाद में नहीं।

— ओलिवियर ग्राएगोयर

n->{var s=""+n;for(int x:n)s=s.replaceFirst("\\d+, 0,? ?","");return s;}(72 बाइट्स), एक सरणी के बजाय एक सूची का उपयोग करता है और आउटपुट के साथ गड़बड़ कर देता है क्योंकि यह "[, 2]" जैसी चीजों को वापस कर सकता है

— ओलिवियर ग्राईगोइरे

@ ओलिवियरग्रेगायर नाइस। हम $एक अतिरिक्त बाइट को बचाने के लिए ड्रॉप कर सकते हैं , क्योंकि 0हम जो भी जोड़ते हैं उसे तुरंत हटा दिया जाता है।

— OOBalance

@ OlivierGrégoire आपका दूसरा दृष्टिकोण भी दिलचस्प है, लेकिन मुझे लगता है कि असंगत आउटपुट प्रारूप समाधान को अमान्य कर सकता है।

— OOBalance

Answer 23

GolfScript , 14 12 बाइट्स

~{.{;}if}/]`

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

~{.{;}if}/]` Full program, implicit input
~            Eval input
 {      }/   Foreach:
      if       If the value is truthy (!= 0):
  .              Push itself
   {;}         Else: pop the top value
          ]` Push as array representation
             Implicit output

Answer 24

पर्ल 5 -p , 17 बाइट्स

साभार @sundar और @DomHastings

s/\d+ 0 ?//&&redo

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

Comments

-2 बाइट्स (थोड़ा मैनकेयर आउटपुट के साथ): इसे ऑनलाइन आज़माएं!

— सूंदर -

इसके अलावा @ sundar की टिप्पणी, एक और मामूली सरलीकरण: इसे ऑनलाइन आज़माएं!

— डोम हेस्टिंग्स

यदि 0942 इनपुट जैसी कोई संख्या नहीं है, तो क्या वह विफल नहीं है?

— Xcali

आप सुरक्षित रूप से मान सकते हैं कि कोई भी अग्रणी शून्य नहीं होगा।

— OOBalance

Answer 25

> <> , 25 बाइट्स

i:?\~~
(0:/:^?
!?l:!<oan;

इसे ऑनलाइन आज़माएं! (इनपुट असीसी में लिखा होना चाहिए। अन्यथा इस का उपयोग करें )

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

i:?\~~0 के लिए चेक, ~~पिछली प्रविष्टि को हटाना जारी रखता है । अन्यथा नीचे जाएं:

(0:/:^? -1 के लिए जांच (कोई और इनपुट नहीं), फिर -1 और लूप को हटाने के लिए लपेटें:

!?l:!<oan; जो प्रत्येक संख्या को एक नई लाइन के साथ आउटपुट करता है, फिर स्टैक खाली होने पर समाप्त होता है

Comments

22 बाइट्स

— जो किंग

Answer 26

भूसी , 6 बाइट्स

चूँकि पहले से कोई हस्क जवाब नहीं है और यह मेरा पसंदीदा गोल्फ-लैंग है:

F`?:tø

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

व्याख्या

F`?:tø  --
F    ø  -- foldl (reduce) with [] as the initial accumulator
 `      -- | flip arguments of
  ?:    -- | | if truthy: apply cons (prepend) to it
    t   -- | | else: return tail
        -- | : returns a function, either prepending the element or dropping 1 element

वैकल्पिक समाधान, 6 बाइट्स

फ़्लिप करने के बजाय, हम केवल सूची को उल्टा कर सकते हैं और फिर राइट-फोल्ड का उपयोग कर सकते हैं: Ḟ?:tø↔

Answer 27

ब्रेनफक , 214 150 बाइट्स

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

इनपुट को नई संख्या द्वारा अलग किए गए नंबरों के रूप में पढ़ता है। इसमें एक एकल अनुगामी न्यूलाइन शामिल होना चाहिए। यह भी उम्मीद है कि प्रत्येक संख्या पर कोई अग्रणी शून्य नहीं है। इसी तरह की नई लाइन से अलग सूची के रूप में आउटपुट

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

स्पष्टीकरण ^{जो वास्तव में स्पष्टीकरण नहीं है, लेकिन वास्तव में केवल संस्करण है जो मैं टिप्पणियों और सामानों के साथ काम कर रहा था जो वास्तव में किसी के लिए उपयोगी हो सकता है या नहीं हो सकता है।}

Stack format:
0 (0 \d*)*


>>,[
    Setup digit == '0' conditional
    >++++++
    [-<-------->]
    +
    <[
        Read digit != '0'
        Restore the char code
        cond1 is already 1 at this stage
        >+++++
        [-<++++++++>]
    ]>[
        Read digit == '0'
        -
        Pop previous value
        <<<[
            [-]<
        ]
        Skip next input (assumed to be newline)
        ,[-]
        Skip following loop by unsetting loop flag
        >>>>-
        <<
    ]

    Move to next stack frame
    >
    Set loop flag
    >+[
        Set bit used for conditional
        <<+
        Read next character
        <,
        Compare with '\n'
        ----------[
            Not '\n': restore the char code
            ++++++++++

            >-
        ]>[
            -
            == '\n': Leave as 0
            Unset loop flag
            >>-
            <
        ]

        Copy loop flag along
        >
        [- > + <]

        Move to loop flag of next stack frame
        >
    ]

    <<<
,]


Fill in with newlines
<<[
    Skip to the cell before this value
    [<]
    Put a newline in there
    ++++++++++
    Move to next value
    <
]

Now the tape has the exact values we need to output
>>[.>]

Answer 28

ब्रेकीलॉग , 21 बाइट्स

~c₃Ckt[İ,0]≠∧C⟨hct⟩↰|

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

-1 बाइट, और इससे भी महत्वपूर्ण बात यह है कि ऐसा करने का तरीका बहुत कम है।

~c₃                     % Partition the input into 3 subarrays
   C                    % Call that array-of-arrays C
    kt[İ,0]             % Its second element should be of the form [Integer, 0]
           ≠            % And its elements shouldn't be equal (i.e. 
                        %   the Integer shouldn't be 0)
            ∧C⟨hct⟩     % Then, remove that [İ, 0] element from C
                   ↰    % And call this predicate recursively
                    |   % When the above fails (when it can't find a partition with 
                        %  [İ, 0] in it), then just output the input

वैकल्पिक 21 बटर: ∋0∧ℕ₁;0;P↺c;Qc?∧P,Q↰| इसे ऑनलाइन आज़माएं!

---

पुराना कोड:

22 बाइट्स

∋0&b,1;?z{=|¬∋0&}ˢtᵐ↰|

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

∋0           If input contains a 0, 
&b           Remove input's first element, getting list of "next" elements
,1           Append 1 to that to handle last element
;?z          Zip that with input
{      }ˢ    Select only zipped pairs where
 =|          both elements are equal (to keep 0s followed by 0s)
   ¬∋0&      or the pair doesn't contain a 0
             this removes both the (pairs containing the) value
              that is followed by a 0, and the 0 itself
tᵐ           Recover back the (filtered) input array elements from the zip
↰            Call this predicate recursively 
|            If input contains no 0s, input is the output 

Answer 29

चेतावनी: लाइनों के बहुत सारे। आपको चेतावनी दी गई है।

---

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

अधिकांश खतरनाक कोड
(माना जाता है कि स्टैक तत्वों को आउटपुट में केवल रिक्त स्थान द्वारा अलग किया जा सकता है और इनपुट सरणी जो भी रूप में हम चाहते हैं) हो सकता है

q~{X0={;}X?}fX]S*

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

व्याख्या

q                                    Reads input string
 ~                                   Instantly convert to array since the string is in the CJam format
  {        }fX                       For loop
   X0=                               If X (the array element currently being checked) is equal to 0
      {;}                            Pop the top element from the stack
         X                           Else push X onto the top of the stack
          ?                          If-Else flag
              ]                      Collate all stack elements into an array
               S*                    Put a space between each array element

---

वैकल्पिक कोड # 1, 27 बाइट्स
(माना जाता है कि स्टैक तत्वों को प्रश्न में दिखाए गए प्रारूप में आउटपुट किया जाना है और इनपुट सरणी जो भी रूप में हम चाहते हैं हो सकता है)

q~{X0={;}X?}fX]',S+*'[\+']+

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

व्याख्या

q                                    Reads input string
 ~                                   Instantly convert to array since the string is in the CJam format
  {        }fX                       For loop
   X0=                               If X (the array element currently being checked) is equal to 0
      {;}                            Pop the top element from the stack
         X                           Else push X onto the top of the stack
          ?                          If-Else flag
              ]                      Collate stack items into an array
               ',S+                  Add together a comma and a space to create a delimiter
                   *                 Apply the delimiter to the stack
                    '[\+             Append left bracket to the left of the stack text
                        ']+          Append right bracket to the right of the stack text

---

वैकल्पिक कोड # 2, 24 बाइट्स
(माना जाता है कि स्टैक तत्वों को आउटपुट में मिलाया जा सकता है और यह कि इनपुट ऐरे को प्रश्न में दिखाए गए सटीक प्रारूप में होना है)

q',/~]S*~{X0={;}X?}fX]S*

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

व्याख्या

q                        Read input string
 ',/                     Separate by commas (since commas are an invalid array delimiter in CJam)
    ~                    Turn string into an array of substrings that make up the array
     ]S*                 Add spaces in between input numbers to prevent collation in the array
        ~                Turn the string into a valid array representative of the original
         {        }fX    For loop
          X0=            If X (the array element currently being checked) is equal to 0
             {;}         Pop the top element from the stack
                X        Else push X onto the top of the stack
                 ?       If-Else flag
                     ]   Collate all stack elements into an array
                      S* Add a space between each element

---

इसके लिए सबसे सुरक्षित कोड, 34 बाइट्स
(स्टैक तत्वों को प्रश्न में दिखाए गए प्रारूप में आउटपुट किया जाना है और इनपुट सरणी को प्रश्न में दिखाए गए सटीक प्रारूप में होना है)

q',/~]S*~{X0={;}X?}fX]',S+*'[\+']+

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

व्याख्या

q                                      Read input string
 ',/                                   Separate by commas (since commas are an invalid array delimiter in CJam)
    ~                                  Turn string into an array of substrings that make up the array
     ]S*                               Add spaces in between input numbers to prevent collation in the array
        ~                              Turn the string into a valid array representative of the original
         {        }fX                  For loop
          X0=                          If X (the array element currently being checked) is equal to 0
             {;}                       Pop the top element from the stack
                X                      Else push X onto the top of the stack
                 ?                     If-Else flag
                     ]                 Collate stack items into an array
                      ',S+             Add together a comma and a space to create a delimiter
                          *            Apply the delimiter to the stack
                           '[\+        Append left bracket to the left of the stack text
                               ']+     Append right bracket to the right of the stack text

---

@Jo किंग के लिए धन्यवाद कि यह इंगित करने के लिए कि टकराए गए आउटपुट वाले लोग अमान्य हैं जैसे कि चीजों के बाद से [12]और [1,2]अप्रभेद्य होगा।

@Jo किंग को भी धन्यवाद, जो कि आउटपुट के लिए एक बहुत ही उपयुक्त विकल्प प्रदान करता है और 9 बाइट्स काट रहा है!

Comments

पहले वाला मान्य नहीं है क्योंकि आप [12]और के बीच का अंतर नहीं बता सकते [1,2]। हालांकि, 27 बाइट संस्करण ठीक लगता है, हालांकि आप 18 बाइट्स के

— जो किंग

ओह, निश्चित रूप से मैं बहुत-बहुत धन्यवाद हूँ

— हेलेन

हालाँकि यह संभवत: अधिक गोलाकार होगा क्योंकि रिक्त स्थान का उपयोग करने के बजाय रिक्त स्थान द्वारा संख्याओं को अलग करना होगा ]S*(3) जबकि अल्पविराम का उपयोग ]',*(4)

— Helen

Answer 30

लाल , 64 बाइट्स

func[b][a: copy[]foreach n b[either n > 0[insert a n][take a]]a]

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