Giriş

Bir kuyruk elemanları olan bir soyut veri türü ön eklendi (enqueue) ve arka kaldırılır (dequeue). Bu aynı zamanda FIFO (First In First Out) ilkesi olarak da bilinir .

En iyi örnekle gösterilmiştir:

Meydan okuma

Pozitif tamsayıları içeren ve boşluğu belirten öğeleri içeren ( boş olan bir öğe) boş olmayan bir dizi göz önüne alındığında , sıranın son listesini çıkar.

Diyelim ki Xbu örnekte bir felaket anlamına geliyor. Aşağıdaki listeye bir göz atalım:

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

Bu, aşağıdaki sıra sözde koduna çevrilebilir:

                   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

Sonunda sonucun, [85, 97]bu sekansın çıktısı olduğunu görebilirsiniz.

Test durumları

XPozitif bir tamsayı olmadıkça, başka bir sembol veya karakter seçebileceğinizi unutmayın .

[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]

Bu kod-golf , bu yüzden en az sayıda bayt olan gönderim kazanıyor!

Jöle , 8 bayt

F;@Ṗṛ?¥/

Sıyrılmak için herhangi bir sahte değeri ( 0 veya boş yinelenebilir) kullanır.

Çevrimiçi deneyin!

Nasıl çalışır

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.

Python 2, 56 53 50 bayt

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

Çevrimiçi Deneyin!

Dequeue olduğunu -1. Bu numara kuyruğun kolay pythonic dilimleme sağlar.

Mathematica, 102 bayt

Kesinlikle en kısa çözüm değil, ama bir türlü sapık olduğu için direnemedim.

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

Bazı yardımcı işlevlerden sonra, bu girdi olarak bir dizgiyi alan saf işlevi tanımlar: dizgede sayılar virgüllerle ayrılır (boşluk isteğe bağlıdır); dequeue karakteri "]"; ve listenin önünde veya arkasında sınırlayıcı yok. Örneğin, OP'deki ilk örnek dizge olarak girilecektir "45,],],37,20,],97,],85". Fonksiyonun çıktısı bir sayılar listesidir.

İşlev "]", giriş dizgisinde kaç tane deformasyon olduğunu sayar , dizenin önüne birçok kopya ekler "f["ve ardından her şeyi çevreler "r[...]". Yukarıdaki örnekte, bu üretir "r[f[f[f[f[45,],],37,20,],97,],85]"; köşeli ayraçların dengeli olduğuna dikkat edin.

Ardından, ToExpressionortaya çıkan dizgiyi bir Mathematica kodu parçası olarak yorumlar ve çalıştırır. İşlev f, birincisi dışındaki tüm argümanlarını korumak için uygun bir şekilde tanımlanmıştır (ve ayrıca izleyen virgülleri yok sayar; bu, yine de boş sıraları boşaltmak için gereklidir) ve relde edilen sayı sırasını doğru sırada bir sayı listesine dönüştürür.

Retina , 30 bayt

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

Çevrimiçi deneyin!

İlk önce (hemen hemen zorunlu olması gerekmeyen) ilk sayıyı, bununla Xbirlikte Xveya Xdizgenin başlangıcında tekrar tekrar kaldırır . Sonra kalan sayıları tersine çevirir.

JavaScript, 70 63 53 50 43 bayt

Döngü ve üçlü ifadeler yerine x.map ile 10 baytlık golf attığınız için teşekkürler @Neil

3 byte kapalı golf için teşekkürler @Arnauld

7 byte kapalı golf için teşekkürler @ETHproductions

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

Çevrimiçi deneyin!

Dequeue, true dışında herhangi bir sayısal olmayan değer olabilir.

Mathematica, 46 45 bayt

1 byte tasarruf için ngenisis teşekkürler.

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

Temelde Retina cevabımla aynı, desen eşleştirmeyi kullanarak İlkini tekrar tekrar eşleştirip Xilk numara ile birlikte kaldırırız (eğer varsa). İşimiz bittikten sonra listeyi tersine çeviririz.

Saf Bash, 72

Komut satırı parametreleri olarak verilen giriş.

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

Çevrimiçi deneyin .

Haskell, 41 bayt

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

Matl , 13 12 bayt

vi"@?@wh}IL)

Giriş 0"dequeue" için bir sayılar dizisidir .

Çıktı, boşluklarla ayrılmış sayılardır. Boş bir sonuç hiçbir şey olarak gösterilmez.

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

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)

Haskell, 41 40 Bayt

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

İşlev foldl(#)[](Ayrıca, aralarında bir bayt ile bytecount dahil

Çevrimiçi deneyin!

X, pozitif olmayan bir tamsayıdır

EDIT: -1, nimi sayesinde

Julia, 78 76 73 57 bayt

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

Bazı mükemmel Julia golf önerileri için Harrison Grodin'e teşekkürler. 16 baytlık bir tasarruf için üçlü ve sonlu / sonlu liste kavrama ile değiştirilirse.

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

3 baytlık bir tasarruf için gereksiz alanların kaldırılması.

Negatif sayılar veya sıfıra izin verilmeden önce:

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

Julia için oldukça yeniyim; daha iyi bir yol olabilir. Kullanımları :XJulia bir sembolüdür X için. Güncelleme: Şimdi 0 izin verilir, X için 0 (veya herhangi bir negatif sayı) kullanır, iki karakter kaydeder. Farkında olmadığım bazı boşlukları kaldırmak için tekrar güncellendi.

05AB1E , 12 11 bayt

Riley sayesinde bir bayt kaydedildi

)Evyai¨ëy¸ì

Çevrimiçi deneyin!

açıklama

Talepler herhangi bir harfle belirtilir .

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

GNU Sed, 43

Puan -rve -nbayrakları kullanımı için +2 içerir .

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

Çevrimiçi deneyin .

açıklama

                            # 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

PHP, 85 Bayt

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

-8 Her dequeue değeri false ise, $vyerine Baytis_int($v)

Python 3 , 95 94 bayt

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

Çevrimiçi deneyin!

Ayrıca 94 bayt:

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

Perl 5 , 28 + 1 = 29 bayt

28 bayt kodu + -pbayrak.

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

Çevrimiçi deneyin!

Bu bir dize (kullanır $\kuyrukta gibi): girdi bir tamsayı (içerdiğinde /\d/?, biz başında ekler $\( $\=$_.$\) ve aksi takdirde biz sonuncusu kaldırmak s/.*\n$//sonunda,. $\Örtülü sayesinde basılır -pbayrağı (ve eşsiz olanlar }{).

Diğer yaklaşımlar:

• 33 bayt , sıra olarak bir dizi kullanarak (bence Perl'de yapmanın en doğal yolu, ama en kısa değil):

  /X/?pop@F:unshift@F,$_}{$_="@F"

  Çevrimiçi deneyin!

• 52 bayt , regex kullanarak ve reverse(Martin Ender'in Retina cevabı ile tamamen aynı şey olur - bunun üzerine 2 bayt kurtardığım için teşekkürler). Listeyi tersine çevirmek çok fazla karakter alır, çünkü tamsayıları korumak için dizeyi diziye dönüştürmeliyim, sonra yazdırmak için dizgeye dönüştürmeliyim. ( say foryerine $_=join$",2 bayt kaydedebilirsiniz, ancak gerektirir -Eveya -M5.010ve o kadar da ilginç değil).

  s/\d+ (.*?)X ?|^X/$1/&&redo;$_=join$",reverse split

  Çevrimiçi deneyin!

Python 3, 107 bayt

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, sayısal olmayan herhangi bir değer olabilir.

Çevrimiçi deneyin

Toplu iş, 160 bayt

@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%

Bu olması gerekenden daha zordu.

• Her ne kadar Batch bir dize bölmenin sonucunu numaralayabilse de, bir öğeyi numaralandırmadan kolayca kaldıramaz.
• İlk öğeyi kaldırabilir, ancak yalnızca en az bir öğe varsa. Aksi takdirde çöp alırsınız.

Bunun anlamı, a) kaldırılmayan bir kuyruk sonu işaretçisi olmalı ve b) kuyruğu öne doğru değiştirmeli, böylece yeni öğeler son işaretleyiciden hemen önce yerleştirilmiş olmalı, böylece eski öğeler önden kaldırılabilir, bu durumda I c) yazdırmadan önce kuyruğu tersine çevirmek zorunda kalırım.

PHP, 70 bayt

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

C #, 115 bayt +33 bayt kullanmak için

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

En sıraya alma ve temizleme işlemlerini gerçekleştirdikten sonra bir tam sayı listesi döndüren adsız yöntem Negatif tam sayılar, elemanları sıradan çıkarmak için kullanılır.

Ungolfed yöntemi ve test vakaları ile tam program:

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

Scala, 97 bayt

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}

Giriş olarak, "dequeue" elemanı olarak fbir liste alır 0. bAkümülatör görevi gören ikinci bir parametreyle ( ) kuyruk özyineleme kullanır . Başlangıçta, bboş Seq( Nil).

Açıklamalar:

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

Not: b dropRight 1 yerine kullanılan b.tailönlemek istisna: tail of empty list.

Test durumları:

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)

fbaşka türlerle de çalışabilir ( String,, char..., hatta bu türlerin heterojen listesi!):

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

REXX, 115 bayt

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

Boşluklu bir dize alır, boşluklu bir dize yazdırır

C ++, 122 119 bayt

#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, bir dequeue olduğunu gösterir.

Çevrimiçi deneyin!

Swift 3, 70 bayt

Bir dizi Ints'e sahip olduğumuzu varsayalım. let x = [1, 2,-1,3,-1,4]

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

Not [].prefix(0)boş ArraySlice almak için sinsi bir yoldur