परिचय

एक कतार एक सार डेटा प्रकार है जहाँ तत्वों को सामने (enqueue) में जोड़ा जाता है और पीछे से हटा दिया जाता है (dequeue)। इसे फीफो (फर्स्ट इन फर्स्ट आउट) के रूप में भी जाना जाता है सिद्धांत के ।

यह एक उदाहरण के साथ सबसे अच्छा दिखाया गया है:

चुनौती

एक गैर-खाली सरणी को देखते हुए जिसमें सकारात्मक पूर्णांक और तत्व होते हैं जो एक संकेत दिखाते हैं (एक तत्व को हटाने) को , कतार की अंतिम सूची का उत्पादन करते हैं।

आइए बताते हैं कि Xइस उदाहरण में एक छल को दर्शाता है। आइए निम्नलिखित सूची पर एक नज़र डालें:

[45, X, X, 37, 20, X, 97, X, 85]

इसका निम्न पंक्ति-छद्म कोड में अनुवाद किया जा सकता है:

                   Queue
Enqueue 45    ->   45
Dequeue       ->   
Dequeue       ->              (dequeue on an empty queue is a no-op)
Enqueue 37    ->   37
Enqueue 20    ->   20 37
Dequeue       ->   20
Enqueue 97    ->   97 20
Dequeue       ->   97
Enqueue 85    ->   85 97

आप देख सकते हैं कि अंत में, परिणाम है [85, 97], जो इस अनुक्रम के लिए आउटपुट है।

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

ध्यान दें कि आप किसी अन्य प्रतीक या चरित्र को चुन सकते हैं X, जब तक कि यह एक पूर्णांक नहीं है।

[1, X, 2, X, 3, X]      ->     []
[1, 2, X]               ->     [2]
[1, 2, 3]               ->     [3, 2, 1]
[1, 2, X, X, X, 3]      ->     [3]
[1, 2, X, 3, X, 4]      ->     [4, 3]

यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ जमा करना!

code-golf number array-manipulation

— अदनान
स्रोत

यह एक सरणी के बजाय एक अंतरिक्ष अलग स्ट्रिंग हो सकता है?

— रिले

@ रिले श्योर, जो भी आपके लिए सबसे अच्छा काम करता है

— अदनान

2

क्या हम x के लिए ऋणात्मक संख्या का उपयोग कर सकते हैं (हास्केल विषम सूचियों का समर्थन नहीं करता है)

— सामान्य प्रदर्शन नाम

2

... या अन्य गैर-गैर-नकारात्मक पूर्णांक जैसे शून्य या आधा?

— जोनाथन एलन

@GenericDisplayName हम्म, अच्छी बात है। जब तक यह एक सकारात्मक पूर्णांक नहीं है मैं इसे अनुमति दूंगा

— अदनान

4

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

F;@Ṗṛ?¥/

किसी भी गलत मान ( 0 या खाली पुनरावृत्ति) का उपयोग करता है ।

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

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

F;@Ṗṛ?¥/  Main link. Argument: A (array)

       /  Reduce A by the link to the left.
      ¥     Combine the two links to the left into a dyadic chain.
F             Flatten the left argument.
    ṛ?        If the right argument is truthy:
 ;@             Concatenate the right argument and the flattened left argument.
              Else:
   Ṗ            Pop; remove the last element of the flattened left argument.
                This is why flattening is required, as Ṗ doesn't handle integers
                as intended for this challenge.

— डेनिस
स्रोत

1

दरअसल इसकी मनाही नहीं है। केवल सकारात्मक पूर्णांक निषिद्ध हैं, 0 तटस्थ है।

— आउटगोल्फर

जब मैंने अपना उत्तर पोस्ट किया, तो ऐसा नहीं था, लेकिन सिर ऊपर करने के लिए धन्यवाद।

— डेनिस

8

पायथन 2, 56 53 50 बाइट्स

q=[]
for i in input():q=[[i]+q,q[:i]][i<0]
print q

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

Dequeue है -1। यह ट्रिक कतार के आसान पायथोनिक स्लाइसिंग की अनुमति देता है।

— गणित के दीवाने
स्रोत

7

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

निश्चित रूप से सबसे छोटा समाधान नहीं है, लेकिन मैं इसका विरोध नहीं कर सकता क्योंकि यह विकृत है।

r=Reverse@{##}&
a_~f~b___:=b
f[a_,b___,]:=b
ToExpression[{"r[","f["~Table~StringCount[#,"]"],#}<>"]"]&

कुछ सहायक कार्यों के बाद, यह एक शुद्ध फ़ंक्शन को परिभाषित करता है जो एक स्ट्रिंग को इनपुट के रूप में लेता है: स्ट्रिंग में, संख्याओं को कॉमा द्वारा अलग किया जाता है (व्हाट्सएप वैकल्पिक है); छल चरित्र है "]"; और सूची में आगे या पीछे के सीमांकक नहीं हैं। उदाहरण के लिए, ओपी में पहला उदाहरण स्ट्रिंग के रूप में इनपुट होगा"45,],],37,20,],97,],85" । फ़ंक्शन का आउटपुट संख्याओं की एक सूची है।

फ़ंक्शन गिना "]"जाता है कि इनपुट स्ट्रिंग में कितने dequeues हैं, यह बताता है कि स्ट्रिंग "f["के सामने की कई प्रतियां हैं , और फिर पूरी चीज को चारों ओर से घेरे हुए है "r[...]"। ऊपर के उदाहरण में, यह पैदा करता है "r[f[f[f[f[45,],],37,20,],97,],85]"; ध्यान दें कि कोष्ठक संतुलित हैं।

फिर, ToExpressionपरिणामस्वरूप स्ट्रिंग को गणितज्ञ कोड के एक टुकड़े के रूप में व्याख्या करता है और इसे निष्पादित करता है। फ़ंक्शन fको आसानी से पहले को छोड़कर अपने सभी तर्कों को बनाए रखने के लिए परिभाषित किया गया है (और ट्रेलिंग कॉमा को भी नजरअंदाज कर देता है; यह वैसे भी खाली कतार को हटाने के लिए आवश्यक है), और rसही क्रम में संख्याओं की सूची में परिणामी अनुक्रम को धर्मान्तरित करता है।

— ग्रेग मार्टिन
स्रोत

क्या लाइन 3 में अल्पविराम होने का b___,मतलब है? यह काम करता है , लेकिन अल्पविराम इसके कारण लाल हो जाता है। (यह भी, 2 और 3 लाइनों के बीच क्या अंतर है?)

— संख्यामान

1

अच्छी आंख :) लाइन 2 f[a_,b___]:=b(अल्पविराम के बिना) के बराबर है, जबकि रेखा 3 के बराबर है f[a_,b___,Null]:=b। दोनों मामलों में, b___किसी भी संख्या के तर्कों को संदर्भित करता है (बिल्कुल भी नहीं)। लाइन 3 अधिक विशिष्ट है, इसलिए हमेशा उपयुक्त होने पर लाइन 2 से पहले उपयोग किया जाता है। इसलिए फ़ंक्शन fअपने पहले तर्क को नजरअंदाज करता है, और यदि वह तर्क है तो अपने अंतिम तर्क की भी अनदेखी करता है Null। यह एक खाली कतार को हटाने के लिए आवश्यक था। ध्यान दें कि एक विशिष्ट इनपुट की तरह एक अभिव्यक्ति निकलेगी r[f[f[f[5,3,],2,],],11], जहां प्रत्येक कॉमा से पहले ]फिर से एक संकेत देता है Null।

— ग्रेग मार्टिन

1

वाह बहुत अच्छा :)। वैसे, मुझे लगता है कि यह वास्तव में 102 बाइट्स है; आपने अंत में एक अतिरिक्त न्यूलाइन वर्ण गिना हो सकता है।

— नंबरमानिक

4

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

1+`\d+,(.*?)X,?|^X,
$1
O^$`\d+

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

बार-बार पहले नंबर को हटाता है (जो जरूरी नहीं कि तुरंत) उसके Xसाथ एक साथ X, या Xस्ट्रिंग की शुरुआत में। फिर शेष संख्याओं को उलट देता है।

— मार्टिन एंडर
स्रोत

4

जावास्क्रिप्ट, 70 63 53 50 43 बाइट्स

धन्यवाद @Neil लूप और टर्नरी अभिव्यक्ति के लिए x.map के साथ 10 बाइट को बंद करने के लिए

धन्यवाद @ बर्न 3 बाइट्स से गोल्फ के लिए

7 बाइट्स को बंद करने के लिए धन्यवाद @ETHproductions

x=>(t=[],x.map(a=>+a?t=[a,...t]:t.pop()),t)

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

सही के अलावा कोई भी गैर-संख्यात्मक मान हो सकता है।

— fənɛtɪk
स्रोत

यह छोटा होगा यदि आप एक if बयान के बजाय एक टर्नरी का उपयोग करते हैं, और तब भी छोटा होता है यदि आप mapएक लूप के बजाय उपयोग करते हैं, और यहां तक कि यदि आप एक ब्लॉक के बजाय एक अभिव्यक्ति का उपयोग करते हैं तो भी छोटा होगा। युक्तियाँ देखें ।

— नील

मैंने पहला संस्करण पोस्ट किया था जिसे मुझे काम मिला। तब मैंने रात का खाना खाया: P

— fəˈn att Mark

आप x=>(t=[],x.map(a=>a>0?t.unshift(a):t.pop()),t)काफी कुछ बाइट्स को बचाने के लिए कर सकते हैंreturn

— ETHproductions

x=>x.map(a=>a>0?t.unshift(a):t.pop(),t=[])&&tऔर भी छोटा है।

— नील

(या सिर्फ a?मुझे लगता है, मुझे लगता है?)

— नील

3

मैथेमेटिका, 46 45 बाइट्स

1 बाइट बचाने के लिए ngenisis के लिए धन्यवाद।

Reverse[#//.{_Integer:0,a___,X,b___}:>{a,b}]&

मूल रूप से मेरे रेटिना उत्तर के समान है, पैटर्न मिलान का उपयोग करते हुए। हम बार-बार पहले से मेल खाते हैं Xऔर इसे पहले नंबर (यदि कोई मौजूद है) के साथ हटा देते हैं। काम पूरा होने के बाद, हम सूची को उल्टा करते हैं।

— मार्टिन एंडर
स्रोत

3

शुद्ध बैश, 72

कमांड-लाइन मापदंडों के रूप में दिया गया इनपुट।

for a;{
[ ${a/X} ]&&q=(${a:n++,0} ${q[@]})||((n-=n>0))
}
echo ${q[@]::n}

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

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

3

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

x&y:z|y<1=init x&z|w<-y:x=w&z
x&y=x
([]&)

— माइकल क्लेन
स्रोत

Ninja'd :) लगता है जैसे हमारे पास एक ही विचार था

— जेनेरिक डिस्प्ले नाम

(हालांकि आपको y: z जैसे चारों ओर कोष्ठक की आवश्यकता हैx&(y:z)

— जेनेरिक डिस्प्ले नाम

यह मेरे आरईपीएल में काम करता है जो गले लगाने का हिस्सा है। मैं हालांकि सटीक संस्करण के बारे में सुनिश्चित नहीं हूं।

— माइकल क्लेन

3

MATL , 13 12 बाइट्स

vi"@?@wh}IL)

इनपुट 0" सरणी " के साथ संख्याओं की एक सरणी है ।

आउटपुट संख्या को रिक्त स्थान से अलग करता है। एक खाली परिणाम के रूप में कुछ भी नहीं दिखाया गया है।

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

व्याख्या

v        % Concatenate stack contents: gives []. This will grow to represent the queue
i        % Input numeric array
"        % For each entry in the input array
  @?     %   If current entry is non-zero
    @wh  %     Prepend current entry to the queue
  }      %   Else
    IL)  %     Remove last element from the queue
         %   End (implicit)
         % End (implicit)
         % Display (implicit)

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

3

हास्केल, 41 40 बाइट्स

l#a|a>0=a:l|l>[]=init l|1>0=l

समारोह है foldl(#)[](बीच में अलगाव के बाइट के साथ बायटेकाउंट में शामिल)

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

एक्स किसी भी गैर-सकारात्मक पूर्णांक है

EDIT: -1 बाइट थैंक्स टू निम्मी

— सामान्य प्रदर्शन का नाम
स्रोत

आप एक बाइट को बचाने के लिए अंतिम दो गार्ड को फ्लिप कर सकते हैं:|l>[]=init l|1>0=l

— nimi

3

जूलिया, 78 76 73 57 बाइट्स

f(a)=(q=[];[x<1?q=q[2:end]:push!(q,x)for x=a];reverse(q))

जूलिया गोल्फिंग के कुछ बेहतरीन सुझावों के लिए हैरिसन ग्रॉडिन को धन्यवाद। 16 बाइट्स की बचत के लिए सूची के साथ टर्नरी और / के साथ / अंत तक प्रतिस्थापित।

f(a)=(q=[];for x in a if x<1 q=q[2:end]else q=[q...,x]end end;reverse(q))

3 बाइट्स की बचत के लिए कुछ अनावश्यक रिक्त स्थान निकाले।

नकारात्मक संख्या या शून्य से पहले अनुमति दी गई थी:

f(a)=(q=[];for x in a if x==:X q=q[2:end] else q=[q...,x] end end;r everse(q))

Ungolfed:

function dequeue(list)
    queue = []

    for x in list
        if x < 1
            queue = queue[2:end]
        else
            queue = [queue..., x]
        end
    end

    reverse(queue)
end

मैं जूलिया के लिए काफी नया हूँ; एक बेहतर तरीका हो सकता है। :Xएक्स के लिए उपयोग करता है, जो जूलिया में एक प्रतीक है। अपडेट किया गया: अब कि 0 की अनुमति है, एक्स के लिए 0 (या किसी भी नकारात्मक संख्या) का उपयोग करता है, दो पात्रों को बचाता है। कुछ व्हाट्सएप को हटाने के लिए फिर से अपडेट किया गया जो मुझे एहसास नहीं था कि जरूरत नहीं है।

— डेविड कोनराड
स्रोत

2

05AB1E , 12 11 बाइट्स

रिले को धन्यवाद दिया

)Evyai¨ëy¸ì

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

व्याख्या

किसी भी पत्र द्वारा दोषों को निरूपित किया जाता है ।

)             # wrap stack in a list (pushes empty list)
 Ev           # for each y in evaluated input
   yai        # if y is a letter
      ¨       # remove the first element of the list
       ëy¸ì   # else, prepend y to the list

— Emigna
स्रोत

2

जीएनयू सैड, 43

स्कोर में -rऔर -nझंडे के उपयोग के लिए +2 शामिल हैं ।

G
s/X\n( *|(.*)\b\S+ *)$/\2/
s/\n/ /
h
$p

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

व्याख्या

                            # Implicitly read the next line
G                           # append a newline, then the contents of the hold space
s/X\n( *|(.*)\b\S+ *)$/\2/  # If the input was an X, remove it, the newline, and any element at the end
s/\n/ /                     # Otherwise if the input was not an X, it is simply enqueued by removing the newline between it and the rest of the line
h                           # save a copy of the queue to the hold space
$p                          # since we're using -n to suppress output at the end of processing each input line, then this explicit print is required in the last line

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

2

PHP, 85 बाइट्स

<?$r=[];foreach($_GET as$v)is_int($v)?array_unshift($r,$v):array_pop($r);print_r($r);

-8 बाइट्स के $vबजाय is_int($v)अगर हर डॉक्यू वैल्यू झूठी है

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

2

पायथन 3 , 95 94 बाइट्स

def f(x):q=[];[*map(lambda s:exec(("q.pop(0)"if q else"","q+=[s]")[s!="X"]),x)];print(q[::-1])

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

इसके अलावा 94 बाइट्स:

def f(x):q=[];[*map(lambda s:exec((("","q.pop(0)")[q>[]],"q+=[s]")[s!="X"]),x)];print(q[::-1])

— Trelzevir
स्रोत

2

पर्ल 5 , 28 + 1 = 29 बाइट्स

कोड + -pध्वज के 28 बाइट्स ।

/\d/?$\=$_.$\:$\=~s/.*
$//}{

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

यह एक स्ट्रिंग ( $\) का उपयोग कतार के रूप में करता है: जब इनपुट में एक पूर्णांक होता है ( /\d/?, हम इसे $\( $\=$_.$\) की शुरुआत में जोड़ते हैं ), और अन्यथा, हम पिछले एक को हटा देते हैं s/.*\n$//। अंत में, $\स्पष्ट रूप से -pध्वज के लिए धन्यवाद मुद्रित किया जाता है (और उन बेजोड़ }{)।

अन्य दृष्टिकोण:

33 बाइट्स , कतार के रूप में एक सरणी का उपयोग करना (यह पर्ल का सबसे स्वाभाविक तरीका है, जो मुझे लगता है, लेकिन सबसे कम नहीं):
```
/X/?pop@F:unshift@F,$_}{$_="@F"
```
इसे ऑनलाइन आज़माएं!
52 बाइट्स , रेगेक्स का उपयोग करना और reverse(यह काफी हद तक मार्टिन एंडर के रेटिना जवाब के समान है - धन्यवाद जिसके लिए मैंने उस पर 2 बाइट्स बचाए थे)। सूची को उल्टा करने में बहुत सारे अक्षर लगते हैं, क्योंकि पूर्णांकों को संरक्षित करने के लिए, मुझे इसे उलटने के लिए स्ट्रिंग को एक सरणी में बदलना होगा, फिर इसे प्रिंट करने के लिए एक स्ट्रिंग पर वापस जाना होगा। ( say forइसके बजाय $_=join$",2 बाइट्स बचा सकता है, लेकिन इसके लिए आवश्यकता है -Eया -M5.010यह दिलचस्प नहीं है)।
```
s/\d+ (.*?)X ?|^X/$1/&&redo;$_=join$",reverse split
```
इसे ऑनलाइन आज़माएं!

— बापू
स्रोत

1

पायथन 3, 107 बाइट्स

def f(x):
 r = []
 for i in x:exec("try:r.pop(0)\nexcept:8;r+=i,".split(";")[type(i)==int])
 return r[::-1]

Dequeuer कोई भी गैर-संख्यात्मक मान हो सकता है।

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

— केर्ड सिक्काहिरिंग
स्रोत

1

बैच, 160 बाइट्स

@set s=.
@for %%n in (%*)do @if %%n==X (call set s=%%s:* =%%)else call set s=%%s:~,-1%%%%n .
@set t=
@for %%n in (%s:~,-1%)do @call set t= %%n%%t%%
@echo%t%

यह होना चाहिए की तुलना में कठिन था।

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

इसका मतलब यह है कि मुझे a) एक अंत-पंक्ति कतार की आवश्यकता है, जिसे हटाया नहीं जाता है, और b) को कतार से पीछे की ओर हेरफेर करना पड़ता है, इसलिए नए आइटम अंत मार्कर से ठीक पहले डाले जाते हैं। ताकि पुरानी वस्तुओं को सामने से हटाया जा सके, जिसका अर्थ है कि मैं ग) को छपाई से पहले कतार को उल्टा करना है।

— नील
स्रोत

1

PHP, 70 बाइट्स

foreach($argv as$v)+$v?$r[]=$v:array_shift($r);krsort($r);print_r($r);

— user63956
स्रोत

1

उपयोग करने के लिए C #, 115 बाइट्स +33 बाइट्स

l=>{var r=new List<int>();foreach(var n in l)if(n<0)try{r.RemoveAt(0);}catch{}else r.Add(n);r.Reverse();return r;};

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

पूर्ण कार्यक्रम असंसाधित विधि और परीक्षण मामलों के साथ:

using System;
using System.Collections.Generic;

public class Program
{
    static void PrintList(List<int> list)
    {
        var s = "{";
        foreach (int element in list)
            s += element + ", ";
        if (s.Length > 1)
            s += "\b\b";
        s += "}";
        Console.WriteLine(s);
    }

    public static void Main()
    {
        Func<List<int>, List<int>> f =
        l =>
        {
            var r = new List<int>();
            foreach (var n in l)
                if (n < 0)
                    try
                    {
                        r.RemoveAt(0);
                    }
                    catch
                    { }
                else
                    r.Add(n);
            r.Reverse();
            return r;
        };

        // test cases:
        var list = new List<int>(new[]{1, -1, 2, -1, 3, -1});   // {}
        PrintList(f(list));

        list = new List<int>(new[]{1, 2, -1});  // {2}
        PrintList(f(list));

        list = new List<int>(new[]{1, 2, 3});   // {3, 2, 1}
        PrintList(f(list));

        list = new List<int>(new[]{1, 2, -1, -1, -1, 3});   // {3}
        PrintList(f(list));

        list = new List<int>(new[]{1, 2, -1, 3, -1, 4});    // {4, 3}
        PrintList(f(list));
    }
}

— adrianmp
स्रोत

1

स्काला, 97 बाइट्स

type S=Seq[_];def f(a:S,b:S):S=a match{case h::t=>f(t,if(h==0)b dropRight 1 else h+:b);case _=>b}

इनपुट fके 0रूप में, "डीक्यू" तत्व के साथ एक सूची लेता है । यह एक दूसरे पैरामीटर ( b) के साथ पूंछ-पुनरावृत्ति का उपयोग करता है , जो एक संचायक के रूप में कार्य करता है। प्रारंभ में, bखाली है Seq( Nil)।

स्पष्टीकरण:

type S=Seq[_]                               // defines a type alias (save 1 byte since Seq[_] is used 3 times)
def f(a: S, b: S): S = {                    // a is the initial list, b is an accumulator
    a match {                           
        case h::t =>                        // if a is non-empty
            f(t,                            // recursive call to f with 1st parameter as the tail
                if (h==0) b dropRight 1     // if h == 0 (dequeue) then remove last element of b,
                else h+:b                   // otherwise, just add h at the beginning of b in recursive call
            )
        case _ => b                         // when the list is empty, return b (final result)
    }
}

नोट: अपवाद से बचने के b dropRight 1बजाय उपयोग किया जाता है :।b.tailtail of empty list

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

f(Seq(45, 0, 0, 37, 20, 0, 97, 0, 85), Nil)     // List(85, 97)
f(Seq(1, 0, 2, 0, 3, 0), Nil)                   // List()
f(Seq(1, 2, 0), Nil)                            // List(2)
f(Seq(1, 2, 3), Nil)                            // List(3, 2, 1)
f(Seq(1, 2, 0, 0, 0, 3), Nil)                   // List(3)
f(Seq(1, 2, 0, 3, 0, 4), Nil)                   // List(4, 3)

fअन्य प्रकारों ( String,, char..., यहां तक कि उन प्रकारों की विषम सूची!) के साथ भी काम कर सकते हैं।

f(Seq(false, '!', "world", 0, "Hello"), Nil)    // List(Hello, world, !)

— norbjd
स्रोत

1

आरएक्सएक्सएक्स, 115 बाइट्स

arg n
do while n>''
  parse var n m n
  if m=X then pull
  else queue m
  end
o=
do while queued()>0
  pull a
  o=a o
  end
say o

एक अंतरिक्ष-पृथक स्ट्रिंग लेता है, एक अंतरिक्ष पृथक स्ट्रिंग प्रिंट करता है

— idrougge
स्रोत

1

सी ++, 122 119 बाइट्स

#import<list>
void f(std::list<int>o,std::list<int>&q){for(int i:o)if(i)q.push_front(i);else if(q.size())q.pop_back();}

0 एक संकेत इंगित करता है।

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

— Steadybox
स्रोत

1

स्विफ्ट 3, 70 बाइट्स

यह मानते हुए कि हमारे पास इनट्स की एक सरणी है let x = [1, 2,-1,3,-1,4]

print(x.reduce([].prefix(0)){(a,i)in return i>0 ?[i]+a:a.dropLast(1)})

ध्यान दें कि [].prefix(0)एक खाली ArraySlice पाने के लिए एक डरपोक तरीका है

— मैट
स्रोत

जब पूर्णांक कतार में शामिल हो जाते हैं

परिचय

चुनौती

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

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

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

पायथन 2, 56 53 50 बाइट्स

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

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

जावास्क्रिप्ट, 70 63 53 50 43 बाइट्स

मैथेमेटिका, 46 45 बाइट्स

शुद्ध बैश, 72

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

MATL , 13 12 बाइट्स

व्याख्या

हास्केल, 41 40 बाइट्स

जूलिया, 78 76 73 57 बाइट्स

05AB1E , 12 11 बाइट्स

जीएनयू सैड, 43

व्याख्या

PHP, 85 बाइट्स

पायथन 3 , 95 94 बाइट्स

पर्ल 5 , 28 + 1 = 29 बाइट्स

पायथन 3, 107 बाइट्स

बैच, 160 बाइट्स

PHP, 70 बाइट्स

उपयोग करने के लिए C #, 115 बाइट्स +33 बाइट्स

स्काला, 97 बाइट्स

आरएक्सएक्सएक्स, 115 बाइट्स

सी ++, 122 119 बाइट्स

स्विफ्ट 3, 70 बाइट्स