Einführung

Eine Warteschlange ist ein abstrakter Datentyp, bei dem Elemente an der Vorderseite (Warteschlange) hinzugefügt und an der Rückseite (Warteschlange) entfernt werden. Dies wird auch als FIFO-Prinzip (First In First Out) bezeichnet.

Es wird am besten anhand eines Beispiels gezeigt:

Herausforderung

Bei einem nicht leeren Array, das positive Ganzzahlen und Elemente enthält, die eine Warteschlange anzeigen (Entfernen eines Elements), geben Sie die endgültige Liste der Warteschlange aus.

Nehmen wir an, dass Xdies in diesem Beispiel eine Warteschlange bedeutet. Werfen wir einen Blick auf die folgende Liste:

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

Dies kann in den folgenden Warteschlangen-Pseudocode übersetzt werden:

                   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

Sie können sehen, dass am Ende das Ergebnis ist [85, 97], welches die Ausgabe für diese Sequenz ist.

Testfälle

Beachten Sie, dass Sie ein beliebiges anderes Symbol oder Zeichen auswählen können X, sofern es sich nicht um eine positive Ganzzahl handelt.

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

Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes!

Gelee , 8 Bytes

F;@Ṗṛ?¥/

Verwendet einen beliebigen falschen Wert ( 0 oder leer, iterabel) zum Löschen.

Probieren Sie es online!

Wie es funktioniert

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 Bytes

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

Probieren Sie es online!

Dequeue ist -1. Dieser Trick ermöglicht ein einfaches pythonisches Durchtrennen der Warteschlange.

Mathematica, 102 Bytes

Auf jeden Fall nicht die kürzeste Lösung, aber ich konnte nicht widerstehen, weil es irgendwie pervers ist.

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

Nach einigen Hilfsfunktionen definiert dies eine reine Funktion, die eine Zeichenfolge als Eingabe verwendet: In der Zeichenfolge werden Zahlen durch Kommas getrennt (Leerzeichen sind optional). der Dequeue-Charakter ist "]"; und die Liste hat keine Begrenzer vorne oder hinten. Beispielsweise würde das erste Beispiel im OP als Zeichenfolge eingegeben "45,],],37,20,],97,],85". Die Ausgabe der Funktion ist eine Liste von Zahlen.

Die Funktion zählt, wie viele Warteschlangen "]"sich in der Eingabezeichenfolge befinden, fügt so viele Kopien "f["an die Vorderseite der Zeichenfolge an und umgibt dann das Ganze mit "r[...]". Im obigen Beispiel ergibt dies "r[f[f[f[f[45,],],37,20,],97,],85]": Beachten Sie, dass die Klammern ausgeglichen sind.

Dann ToExpressioninterpretiert die resultierende Zeichenfolge als ein Stück Mathematica - Code und führt ihn aus . Die Funktion fist so definiert, dass alle Argumente mit Ausnahme des ersten Argumentes beibehalten werden (und nachfolgende Kommas ignoriert werden; dies ist ohnehin erforderlich, um leere Warteschlangen aus der Warteschlange zu entfernen). rDie resultierende Zahlenfolge wird in eine Liste mit Zahlen in der richtigen Reihenfolge umgewandelt.

Netzhaut , 30 Bytes

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

Probieren Sie es online!

Entfernt wiederholt die erste Zahl, auf die (nicht unbedingt sofort) ein Xzusammen mit Xoder ein Xam Anfang der Zeichenfolge folgt . Dann kehrt man die restlichen Zahlen um.

JavaScript, 70 63 53 50 43 Bytes

Vielen Dank an @Neil, dass er 10 Bytes mit x.map anstelle von Loop und ternärem Ausdruck abgelegt hat

Vielen Dank an @Arnauld für das Golfen mit 3 Bytes

Vielen Dank an @ETHproductions für das Abschlagen von 7 Bytes

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

Probieren Sie es online!

"Dequeue" kann ein beliebiger nicht numerischer Wert sein, der nicht "true" ist.

Mathematica, 46 45 Bytes

Dank an ngenisis für das Speichern von 1 Byte.

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

Grundsätzlich das Gleiche wie meine Retina-Antwort unter Verwendung von Pattern Matching. Wir gleichen den ersten wiederholt ab Xund entfernen ihn zusammen mit der ersten Nummer (falls vorhanden). Nachdem wir fertig sind, kehren wir die Liste um.

Pure Bash, 72

Eingabe als Befehlszeilenparameter.

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

Probieren Sie es online aus .

Haskell, 41 Bytes

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

MATL , 13 - 12 Bytes

vi"@?@wh}IL)

Die Eingabe ist ein Array von Zahlen mit der 0Bezeichnung "dequeue".

Die Ausgabe erfolgt durch Leerzeichen getrennte Zahlen. Ein leeres Ergebnis wird als nichts angezeigt.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

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 Bytes

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

Funktion ist foldl(#)[](auch in bytecount mit einem Byte Trennung dazwischen enthalten)

Probieren Sie es online!

X ist eine beliebige nicht positive ganze Zahl

EDIT: -1 Byte dank nimi

Julia, 78 76 73 57 Bytes

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

Vielen Dank an Harrison Grodin für einige exzellente Julia Golf Vorschläge. Ersetzt, wenn / else mit ternär und für / end mit Listenverständnis für eine Einsparung von 16 Bytes.

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

Einige unnötige Leerzeichen wurden entfernt, um 3 Byte zu sparen.

Bevor negative Zahlen oder Nullen erlaubt waren:

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

Ich bin ziemlich neu für Julia; Es könnte einen besseren Weg geben. Verwendet :Xfür X, was in Julia ein Symbol ist. Aktualisiert: Jetzt, da 0 zulässig ist, wird 0 (oder eine beliebige negative Zahl) für X verwendet, wobei zwei Zeichen gespeichert werden. Erneut aktualisiert, um einige Leerzeichen zu entfernen, von denen ich nicht wusste, dass sie nicht benötigt wurden.

05AB1E , 12 11 Bytes

Dank Riley ein Byte gespeichert

)Evyai¨ëy¸ì

Probieren Sie es online!

Erläuterung

Warteschlangen werden durch einen Buchstaben gekennzeichnet .

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

Die Punktzahl enthält +2 für die Verwendung der -rund -n-Flaggen.

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

Probieren Sie es online aus .

Erläuterung

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

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

-8 Bytes $vanstelle von is_int($v)false, wenn jeder Dequeue-Wert zu false gehört

Python 3 , 95 bis 94 Bytes

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

Probieren Sie es online!

Auch 94 Bytes:

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 Bytes

28 Byte Code + -pFlag.

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

Probieren Sie es online!

Es wird eine Zeichenfolge ( $\) als Warteschlange verwendet: Wenn die Eingabe eine Ganzzahl enthält ( /\d/?wir hängen sie am Anfang von $\( $\=$_.$\) an und entfernen ansonsten die letzte mit s/.*\n$//. Am Ende $\wird sie implizit gedruckt, dank -pflag (und unübertroffene }{).

Andere Ansätze:

• 33 Bytes , wobei ein Array als Warteschlange verwendet wird (dies ist meiner Meinung nach die natürlichste Methode in Perl, aber nicht die kürzeste):

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

  Probieren Sie es online!

• 52 Bytes mit Regex und reverse(es ist genau dasselbe wie Martin Enders Retina-Antwort - danke, dass ich 2 Bytes darauf gespeichert habe). Das Umkehren der Liste erfordert jedoch viele Zeichen, da ich zum Beibehalten der Ganzzahlen die Zeichenfolge in ein Array konvertieren muss, um sie umzukehren, und dann wieder in eine Zeichenfolge, um sie zu drucken. ( say forstatt $_=join$",2 Bytes speichern können, aber es erfordert -Eoder-M5.010 und es ist nicht so interessant).

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

  Probieren Sie es online!

Python 3, 107 Bytes

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 kann ein beliebiger nicht numerischer Wert sein.

Probieren Sie es online aus

Batch, 160 Bytes

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

Das war schwieriger als es sein musste.

• Obwohl Batch das Ergebnis des Aufteilens einer Zeichenfolge auflisten kann, kann ein Element nicht einfach aus der Aufzählung entfernt werden.
• Das erste Element kann entfernt werden, jedoch nur, wenn mindestens ein Element vorhanden ist. Sonst kriegt man Müll.

Dies bedeutet, dass ich a) einen Marker für das Ende der Warteschlange haben muss, der nicht entfernt wird, und b) die Warteschlange von hinten nach vorne manipulieren muss, damit neue Elemente direkt vor dem Marker für das Ende eingefügt werden, so dass alte Gegenstände von vorne entfernt werden können, was dann bedeutet, dass ich c) die Warteschlange umkehren muss, bevor ich sie drucke.

PHP, 70 Bytes

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

C #, 115 Bytes +33 Bytes für die Verwendung

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

Anonyme Methode, die eine Liste von Ganzzahlen zurückgibt, nachdem die Ein- und Ausreihvorgänge ausgeführt wurden. Negative Ganzzahlen werden zum Entfernen von Elementen aus der Warteschlange verwendet.

Volles Programm mit ungolfed Methode und Testfällen:

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 Bytes

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}

Nimmt als Eingabe feine Liste mit 0als "dequeue" -Element. Es verwendet die Schwanzrekursion mit einem zweiten Parameter ( b), der als Akkumulator fungiert. Anfangs bist das leer Seq( Nil).

Erklärungen:

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

Hinweis: b dropRight 1 wird anstelle von b.tailzu vermeiden Ausnahme: tail of empty list.

Testfälle:

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)

fkann auch mit anderen Typen arbeiten ( String,char , ..., auch heterogene Liste dieser Arten!):

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

REXX, 115 Bytes

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

Nimmt eine durch Leerzeichen getrennte Zeichenfolge und druckt eine durch Leerzeichen getrennte Zeichenfolge

C ++, 122 119 Bytes

#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 steht für eine Warteschlange.

Probieren Sie es online!

Schnelle 3, 70 Bytes

Angenommen, wir haben eine Reihe von Ints wie let x = [1, 2,-1,3,-1,4]

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

Beachten Sie, dass dies [].prefix(0)eine einfache Möglichkeit ist, ein leeres ArraySlice zu erhalten