ভূমিকা

একটি সারি একটি বিমূর্ত ডেটা টাইপ যেখানে উপাদানগুলি সামনে (এনকুই) যুক্ত করা হয় এবং পিছনে (ডিকু) থেকে সরানো হয় । এটি ফিফো (ফার্স্ট ইন ফার্স্ট আউট) নীতি হিসাবেও পরিচিত ।

এটি একটি উদাহরণ সহ সেরা দেখানো হয়েছে:

চ্যালেঞ্জ

একটি শূন্য খালি অ্যারে দেওয়া হয়েছে যাতে ধনাত্মক পূর্ণসংখ্যার এবং উপাদান রয়েছে যা একটি ডিকু (একটি উপাদান অপসারণ) নির্দেশ করে, সারির চূড়ান্ত তালিকা আউটপুট দেয়।

এর 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

আমরা কি এক্স এর জন্য একটি নেতিবাচক সংখ্যা ব্যবহার করতে পারি (হাস্কেল ভিন্নজাতীয় তালিকা সমর্থন করে না)

— জেনেরিক প্রদর্শন নাম

2

... বা অন্যান্য অ-নে-নেগেটিভ পূর্ণসংখ্যার মতো শূন্য বা অর্ধ?

— জোনাথন অ্যালান

@ জেনেরিকডিসপ্লে নেম হুম, ভাল কথা। যতক্ষণ না এটি ইতিবাচক পূর্ণসংখ্যার না হয় আমি এটির অনুমতি দেব

— আদনান

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

গণিত, ১০২ বাইট

অবশ্যই সংক্ষিপ্ততম সমাধান নয়, তবে আমি প্রতিরোধ করতে পারিনি কারণ এটি একধরণের বিকৃত।

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

কিছু সহায়ক ফাংশন পরে, এটি একটি খাঁটি ফাংশন সংজ্ঞায়িত করে যা স্ট্রিংটিকে ইনপুট হিসাবে গ্রহণ করে: স্ট্রিংয়ের মধ্যে নম্বরগুলি কমা দ্বারা পৃথক করা হয় (হোয়াইটস্পেস alচ্ছিক); প্রজাতির চরিত্রটি হ'ল "]"; এবং তালিকার সামনে বা পিছনে ডিলিমিটার নেই। উদাহরণস্বরূপ, ওপিতে প্রথম উদাহরণটি স্ট্রিং হিসাবে ইনপুট হবে "45,],],37,20,],97,],85"। ফাংশনের আউটপুট হল সংখ্যার একটি তালিকা।

ফাংশনটি "]"ইনপুট স্ট্রিংয়ে কতগুলি ডেকিউ রয়েছে তা গণনা করে , স্ট্রিংয়ের "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 বাইট

লুপ এবং টেরিনারি এক্সপ্রেশন না দিয়ে x.map দিয়ে 10 বাইট বন্ধ করে দেওয়ার জন্য @ নীলকে ধন্যবাদ

3 বাইট বন্ধ করে গল্ফ করার জন্য @ আরনাউল্ডকে ধন্যবাদ Thanks

7 বাইট বন্ধ করে গল্ফ করার জন্য @ ইটিএইচ প্রডাকশনস ধন্যবাদ

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

এটি অনলাইন চেষ্টা করুন!

Dequeue সত্য ব্যতীত অন্য কোনও সংখ্যাসূচক মান হতে পারে।

— fənɛtɪk
সূত্র

আপনি যদি if বিবৃতিটির পরিবর্তে একটি ত্রৈমাসিকটি ব্যবহার করেন তবে এটি সংক্ষিপ্ত হবে এবং আপনি যদি mapএকটি লুপের পরিবর্তে ব্যবহার করেন তবে এমনকি যদি আপনি কোনও ব্লকের পরিবর্তে কোনও অভিব্যক্তি ব্যবহার করেন তবে ছোটও হবে। টিপস দেখুন ।

— নীল

আমি প্রথম সংস্করণটি কাজ করেছিলাম। তারপরে আমি রাতের খাবার খেয়েছি: P

— fəˈnɛtɪk

আপনি কি করতে পারেন 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 বাইট সংরক্ষণের জন্য নেজেনিসিসকে ধন্যবাদ।

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
([]&)

— মাইকেল ক্লিন
সূত্র

নিনজা'ড :) মনে হচ্ছে আমাদের একই ধারণা ছিল

— জেনেরিক প্রদর্শন নাম

(আপনি y অক্ষের চারপাশে প্রথম বন্ধনী প্রয়োজন যদিও: z- র মতx&(y:z)

— জেনেরিক প্রদর্শন নাম

এটি আমার আরপিএলে কাজ করে যা আলিঙ্গনের অংশ। যদিও আমি সঠিক সংস্করণ সম্পর্কে নিশ্চিত নই।

— মাইকেল ক্লেইন

3

এমএটিএল , 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(#)[](এর মধ্যে বিচ্ছেদ বাইট সহ বাইকোন্টে অন্তর্ভুক্ত)

এটি অনলাইন চেষ্টা করুন!

এক্স কোনও ধনাত্মক পূর্ণসংখ্যা inte

সম্পাদনা: -১ বাইট নিমিকে ধন্যবাদ

— জেনেরিক প্রদর্শনের নাম
সূত্র

বাইট সংরক্ষণ করতে আপনি শেষ দুটি রক্ষীকে ফ্লিপ করতে পারেন:|l>[]=init l|1>0=l

— নিমি

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

05 এ বি 1 ই , 12 11 বাইট

রিলে একটি বাইট ধন্যবাদ সংরক্ষণ করা

)Evyai¨ëy¸ì

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

Dequeues যে কোনও চিঠি দ্বারা চিহ্নিত করা হয় ।

)             # 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

পিএইচপি, 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 বাইট

28 বাইট কোড + -pপতাকা।

/\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%

এটি করা দরকারের চেয়ে শক্ত ছিল।

যদিও ব্যাচ স্ট্রিংকে বিভক্ত করার ফলাফলটি গণনা করতে পারে, তবে এটি সহজেই গণনা থেকে কোনও উপাদান সরাতে পারে না।
এটি প্রথম আইটেমটি সরিয়ে ফেলতে পারে তবে কেবল কমপক্ষে একটি আইটেম থাকলে। অন্যথায় আপনি আবর্জনা পেতে।

এর অর্থ হ'ল আমার ক) একটি শেষ-কাতার চিহ্ন থাকা দরকার, যা সরিয়ে দেওয়া হয় না, এবং খ) সামনের সারিতে সামনের দিকে সামলাতে হয়, সুতরাং শেষের চিহ্নিতকারীর ঠিক আগে নতুন আইটেম inোকানো হবে, যাতে পুরানো আইটেমগুলি সামনে থেকে সরিয়ে ফেলা যায়, যার অর্থ হল আমি সি) এটি মুদ্রণের আগে সারিটি বিপরীত করতে হবে।

— নিল
সূত্র

1

পিএইচপি, 70 বাইট

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

— user63956
সূত্র

1

সি #, 115 বাইট +৩৩ বাইট ব্যবহারের জন্য

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;};

বেনামে পদ্ধতি যা এন-কুইং এবং শর্তযুক্ত ক্রিয়াকলাপ সম্পাদনের পরে পূর্ণসংখ্যার একটি তালিকা দেয়। Queণাত্মক পূর্ণসংখ্যাগুলি সারি থেকে উপাদানগুলি সরানোর জন্য ব্যবহৃত হয়।

অসম্পূর্ণ পদ্ধতি এবং পরীক্ষার কেস সহ সম্পূর্ণ প্রোগ্রাম:

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}

ইনপুট হিসাবে, "dequeue" উপাদান হিসাবে 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.tailএড়ানোর ব্যতিক্রম: tail 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

রেক্সএক্স, ১১১ বাইট

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)খালি অ্যারেস্লাইস পাওয়ার জন্য একটি ছদ্মবেশী উপায়

— ঔজ্বল্যহীন
সূত্র

যখন পূর্ণসংখ্যা কাতারে যোগদান করে

ভূমিকা

চ্যালেঞ্জ

পরীক্ষার মামলা

জেলি , 8 বাইট

কিভাবে এটা কাজ করে

পাইথন 2, 56 53 50 বাইট

গণিত, ১০২ বাইট

রেটিনা , 30 বাইট

জাভাস্ক্রিপ্ট, 70 63 53 50 43 বাইট

গণিত, 46 45 বাইট

খাঁটি বাশ, 72

হাস্কেল, 41 বাইট

এমএটিএল , 13 12 বাইট

ব্যাখ্যা

হাস্কেল, 41 40 বাইট

জুলিয়া, 78 76 73 57 বাইট

05 এ বি 1 ই , 12 11 বাইট

জিএনইউ সেড, 43

ব্যাখ্যা

পিএইচপি, 85 বাইট

পাইথন 3 , 95 94 বাইট

পার্ল 5 , 28 + 1 = 29 বাইট

পাইথন 3, 107 বাইট

ব্যাচ, 160 বাইট

পিএইচপি, 70 বাইট

সি #, 115 বাইট +৩৩ বাইট ব্যবহারের জন্য

স্কালা, 97 বাইট

রেক্সএক্স, ১১১ বাইট

সি ++, 122 119 বাইট

সুইফট 3, 70 বাইট