introduction

Une file d'attente est un type de données abstrait où des éléments sont ajoutés à l'avant (mise en file d'attente) et supprimés à l'arrière ( retrait de file d'attente ). Il s'agit également du principe FIFO (First In First Out) .

Il est mieux illustré par un exemple:

Défi

Etant donné un non-vide tableau qui contient des nombres entiers positifs et des éléments qui indiquent une dequeue (suppression d' un élément de sortie), la liste finale de la file d' attente.

Disons que cela Xdénote une file d'attente dans cet exemple. Jetons un œil à la liste suivante:

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

Cela peut être traduit dans le pseudo-code de file d'attente suivant:

                   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

Vous pouvez voir qu'à la fin, le résultat est [85, 97], qui est la sortie de cette séquence.

Cas de test

Notez que vous pouvez choisir n'importe quel autre symbole ou caractère X, tant qu'il ne s'agit pas d'un entier positif.

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

C'est du code-golf , donc la soumission avec le moins d'octets gagne!

Gelée , 8 octets

F;@Ṗṛ?¥/

Utilise n'importe quelle valeur falsifiée ( 0 ou vide itérable) pour retirer la file d'attente .

Essayez-le en ligne!

Comment ça marche

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 octets

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

Essayez-le en ligne!

La file d'attente est -1. Cette astuce permet un découpage pythonique facile de la file d'attente.

Mathematica, 102 octets

Certainement pas la solution la plus courte, mais je n'ai pas pu résister car c'est un peu pervers.

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

Après quelques fonctions d'assistance, cela définit une fonction pure qui prend une chaîne en entrée: dans la chaîne, les nombres sont séparés par des virgules (les espaces sont facultatifs); le caractère de file d'attente est "]"; et la liste n'a pas de délimiteurs à l'avant ou à l'arrière. Par exemple, le premier exemple dans l'OP serait entré comme chaîne "45,],],37,20,],97,],85". La sortie de la fonction est une liste de nombres.

La fonction compte le nombre de files d'attente "]"dans la chaîne d'entrée, ajoute ce nombre de copies "f["à l'avant de la chaîne, puis entoure le tout par "r[...]". Dans l'exemple ci-dessus, cela produit "r[f[f[f[f[45,],],37,20,],97,],85]"; remarquez que les crochets sont équilibrés.

Ensuite, ToExpressioninterprète la chaîne résultante comme un morceau de code Mathematica et l'exécute. La fonction fest définie de manière pratique pour conserver tous ses arguments, sauf le premier (et ignore également les virgules de fin; cela est nécessaire pour gérer la file d'attente vide de toute façon) et rconvertit la séquence de nombres résultante en une liste de nombres dans le bon ordre.

Rétine , 30 octets

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

Essayez-le en ligne!

Supprime à plusieurs reprises le premier nombre qui (pas nécessairement immédiatement) suivi d'un Xensemble avec cela X, ou d'un Xau début de la chaîne. Inverse ensuite les chiffres restants.

JavaScript, 70 63 53 50 43 octets

Merci @Neil pour avoir joué 10 octets avec x.map au lieu de pour l'expression en boucle et ternaire

Merci @Arnauld d'avoir joué au golf sur 3 octets

Merci @ETHproductions pour avoir joué au golf sur 7 octets

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

Essayez-le en ligne!

La mise en file d'attente peut être toute valeur non numérique autre que true.

Mathematica, 46 45 octets

Merci à ngenisis pour avoir économisé 1 octet.

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

Fondamentalement, la même chose que ma réponse Retina, en utilisant la correspondance de motifs. Nous faisons correspondre à plusieurs reprises le premier Xet le supprimons avec le premier numéro (s'il en existe un). Une fois que nous avons terminé, nous inversons la liste.

Pure Bash, 72

Entrée donnée comme paramètres de ligne de commande.

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

Essayez-le en ligne .

Haskell, 41 octets

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

MATL , 13 12 octets

vi"@?@wh}IL)

L'entrée est un tableau de nombres, avec 0pour "dequeue".

La sortie est des nombres séparés par des espaces. Un résultat vide est affiché comme rien.

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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 octets

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

La fonction est foldl(#)[](également incluse dans le nombre d'octets avec un octet de séparation entre les deux)

Essayez-le en ligne!

X est un entier non positif

EDIT: -1 octet grâce à nimi

Julia, 78 76 73 57 octets

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

Merci à Harrison Grodin pour ses excellentes suggestions de golf Julia. Remplacé if / else par ternaire et for / end par compréhension de liste pour une économie de 16 octets.

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

Suppression de certains espaces inutiles pour une économie de 3 octets.

Avant que les nombres négatifs ou zéro ne soient autorisés:

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

Non golfé:

function dequeue(list)
    queue = []

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

    reverse(queue)
end

Je suis assez nouveau pour Julia; il peut y avoir une meilleure façon. Utilise :XX, qui est un symbole dans Julia. Mise à jour: Maintenant que 0 est autorisé, utilise 0 (ou tout nombre négatif) pour X, enregistrant deux caractères. Mis à jour à nouveau pour supprimer certains espaces dont je ne savais pas qu'ils n'étaient pas nécessaires.

05AB1E , 12 11 octets

Un octet enregistré grâce à Riley

)Evyai¨ëy¸ì

Essayez-le en ligne!

Explication

Les files d'attente sont indiquées par n'importe quelle lettre .

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

Le score inclut +2 pour l'utilisation des drapeaux -ret -n.

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

Essayez-le en ligne .

Explication

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

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

-8 octets $vau lieu de is_int($v)si chaque valeur de mise en file d'attente appartient à false

Python 3 , 95 94 octets

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

Essayez-le en ligne!

Aussi 94 octets:

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 octets

28 octets de code + -pindicateur.

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

Essayez-le en ligne!

Il utilise une chaîne ( $\) comme file d'attente: lorsque l'entrée contient un entier ( /\d/?, nous l'ajoutons au début de $\( $\=$_.$\), et sinon, nous supprimons le dernier avec s/.*\n$//. À la fin, $\est implicitement imprimé grâce à -pflag (et ceux inégalés }{).

Autres approches:

• 33 octets , en utilisant un tableau comme file d'attente (c'est le moyen le plus naturel de le faire en Perl je pense, mais pas le plus court):

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

  Essayez-le en ligne!

• 52 octets , en utilisant regex et reverse(il se trouve que c'est exactement la même chose que la réponse Retina de Martin Ender - grâce à qui j'ai économisé 2 octets dessus). Inverser la liste prend beaucoup de caractères cependant, car pour préserver les entiers, je dois convertir la chaîne en un tableau pour l'inverser, puis revenir à une chaîne pour l'imprimer. ( say forau lieu de $_=join$",peut économiser 2 octets, mais cela nécessite -Eou -M5.010et ce n'est pas si intéressant).

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

  Essayez-le en ligne!

Python 3, 107 octets

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 peut être n'importe quelle valeur non numérique.

Essayez-le en ligne

Lot, 160 octets

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

C'était plus difficile que nécessaire.

• Bien que Batch puisse énumérer le résultat du fractionnement d'une chaîne, il ne peut pas facilement supprimer un élément de l'énumération.
• Il peut supprimer le premier élément, mais uniquement s'il existe au moins un élément. Sinon, vous obtenez des ordures.

Cela signifie que j'ai a) besoin d'un marqueur de fin de file d'attente, qui ne soit pas supprimé, et b) que je doive manipuler la file d'attente en arrière, de sorte que de nouveaux éléments soient insérés juste avant le marqueur de fin, afin que les anciens éléments puissent être retirés de l'avant, ce qui signifie alors que je c) dois inverser la file d'attente avant de l'imprimer.

PHP, 70 octets

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

C #, 115 octets +33 octets pour l'utilisation

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

Méthode anonyme qui renvoie une liste d'entiers après avoir effectué les opérations de mise en file d'attente et de mise en file d'attente. Les entiers négatifs sont utilisés pour supprimer des éléments de la file d'attente.

Programme complet avec méthode non golfée et cas de test:

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 octets

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}

En entrée, fprend une liste avec 0comme élément "dequeue". Il utilise la récursivité de queue avec un second paramètre ( b), agissant comme un accumulateur. Initialement, bc'est le empty Seq( Nil).

Explications:

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

Note: b dropRight 1 est utilisé au lieu b.taild'éviter exception: tail of empty list.

Cas de test:

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)

fpeut également fonctionner avec d' autres types ( String, char, ..., même liste hétérogène de ces types!):

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

REXX, 115 octets

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

Prend une chaîne séparée par des espaces, imprime une chaîne séparée par des espaces

C ++, 122 119 octets

#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 indique une file d'attente.

Essayez-le en ligne!

Swift 3, 70 octets

En supposant que nous ayons un tableau d'Ints comme let x = [1, 2,-1,3,-1,4]

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

Notez que [].prefix(0)c'est un moyen sournois d'obtenir un ArraySlice vide