Introducción

Una cola es un tipo de datos abstractos donde los elementos se agregan al frente (en cola) y se eliminan de la parte posterior (cola). Esto también se conoce como el principio FIFO (Primero en entrar, primero en salir) .

Se muestra mejor con un ejemplo:

Reto

Dada una matriz no vacía que contiene enteros positivos y elementos que indican una cola (eliminar un elemento), genera la lista final de la cola.

Digamos que Xdenota una dequeue en este ejemplo. Echemos un vistazo a la siguiente lista:

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

Esto se puede traducir al siguiente seudocódigo de cola:

                   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

Puede ver que al final, el resultado es [85, 97], que es la salida para esta secuencia.

Casos de prueba

Tenga en cuenta que puede elegir cualquier otro símbolo o carácter X, siempre que no sea un número entero positivo.

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

Este es el código golf , por lo que gana el envío con la menor cantidad de bytes

Jalea , 8 bytes

F;@Ṗṛ?¥/

Utiliza cualquier valor falso ( 0 o vacío iterable) para quitar.

Pruébalo en línea!

Cómo funciona

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

Pruébalo en línea!

Dequeue es -1. Este truco permite un fácil corte pitónico de la cola.

Mathematica, 102 bytes

Definitivamente no es la solución más corta, pero no pude resistirme porque es algo perverso.

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

Después de algunas funciones auxiliares, esto define una función pura que toma una cadena como entrada: en la cadena, los números están separados por comas (el espacio en blanco es opcional); el personaje dequeue es "]"; y la lista no tiene delimitadores en la parte frontal o posterior. Por ejemplo, el primer ejemplo en el OP se ingresaría como la cadena "45,],],37,20,],97,],85". La salida de la función es una lista de números.

La función cuenta cuántas dequeues "]"hay en la cadena de entrada, agrega muchas copias "f["al frente de la cadena y luego rodea todo "r[...]". En el ejemplo anterior, esto produce "r[f[f[f[f[45,],],37,20,],97,],85]"; Observe que los soportes están equilibrados.

Luego, ToExpressioninterpreta la cadena resultante como un fragmento de código de Mathematica y la ejecuta. La función fse define convenientemente para retener todos sus argumentos, excepto el primero (y también ignora las comas finales; de todos modos, esto es necesario para manejar la eliminación de colas vacías) y rconvierte la secuencia resultante de números en una lista de números en el orden correcto.

Retina , 30 bytes

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

Pruébalo en línea!

Repetidamente elimina el primer número que (no necesariamente inmediatamente) seguido de un Xjunto con ese X, o un Xal comienzo de la cadena. Luego invierte los números restantes.

JavaScript, 70 63 53 50 43 bytes

Gracias @Neil por jugar 10 bytes con x.map en lugar de bucle y expresión ternaria

Gracias @Arnauld por jugar 3 bytes

Gracias @ETHproductions por jugar golf en 7 bytes

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

Pruébalo en línea!

Dequeue puede ser cualquier valor no numérico que no sea verdadero.

Mathematica, 46 45 bytes

Gracias a ngenisis por guardar 1 byte.

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

Básicamente lo mismo que mi respuesta Retina, usando la coincidencia de patrones. Emparejamos repetidamente el primero Xy lo eliminamos junto con el primer número (si existe). Una vez que terminamos, revertimos la lista.

Pure Bash, 72

Entrada dada como parámetros de línea de comando.

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

Pruébalo en línea .

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)

La entrada es una matriz de números, con 0"dequeue".

La salida es números separados por espacios. Un resultado vacío se muestra como nada.

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

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

La función es foldl(#)[](también incluida en el bytecount con un byte de separación en el medio)

Pruébalo en línea!

X es cualquier número entero no positivo

EDITAR: -1 byte gracias a nimi

Julia, 78 76 73 57 bytes

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

Gracias a Harrison Grodin por algunas excelentes sugerencias de golf de Julia. Reemplazado if / else con ternary y for / end con comprensión de lista para un ahorro de 16 bytes.

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

Se eliminaron algunos espacios innecesarios para un ahorro de 3 bytes.

Antes de que se permitieran números negativos o cero:

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

Sin 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

Soy bastante nuevo para Julia; Puede haber una mejor manera. Utiliza :Xpara X, que es un símbolo en Julia. Actualizado: ahora que 0 está permitido, usa 0 (o cualquier número negativo) para X, guardando dos caracteres. Se actualizó nuevamente para eliminar algunos espacios en blanco que no sabía que no eran necesarios.

05AB1E , 12 11 bytes

Salvó un byte gracias a Riley

)Evyai¨ëy¸ì

Pruébalo en línea!

Explicación

Los retrasos se denotan con cualquier letra .

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

La puntuación incluye +2 por el uso de las banderas -ry -n.

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

Pruébalo en línea .

Explicación

                            # 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 en $vlugar de is_int($v)si cada valor de la cola pertenece a falso

Python 3 , 95 94 bytes

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

Pruébalo en línea!

También 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 bytes de código + -pbandera.

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

Pruébalo en línea!

Utiliza una cadena ( $\) como cola: cuando la entrada contiene un número entero ( /\d/?, lo agregamos al principio de $\( $\=$_.$\), y de lo contrario, eliminamos el último con s/.*\n$//. Al final, $\se imprime implícitamente gracias a -pflag (y los inigualables }{)

Otros enfoques:

• 33 bytes , usando una matriz como la cola (creo que es la forma más natural de hacerlo en Perl, pero no la más corta):

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

  Pruébalo en línea!

• 52 bytes , usando expresiones regulares y reverse(resulta ser exactamente lo mismo que la respuesta Retina de Martin Ender, gracias a quien guardé 2 bytes en él). Sin embargo, invertir la lista requiere muchos caracteres, porque para preservar los enteros, tengo que convertir la cadena en una matriz para invertirla, luego volver a una cadena para imprimirla. (en say forlugar de $_=join$",puede guardar 2 bytes, pero requiere -Eo -M5.010y no es tan interesante).

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

  Pruébalo en línea!

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 puede ser cualquier valor no numérico.

Pruébalo en línea

Lote, 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%

Esto fue más difícil de lo necesario.

• Aunque Batch puede enumerar el resultado de dividir una cadena, no puede eliminar fácilmente un elemento de la enumeración.
• Puede eliminar el primer elemento, pero solo si hay al menos un elemento. De lo contrario, obtienes basura.

Esto significa que yo a) necesito tener un marcador de fin de cola, que no se elimine, yb) tengo que manipular la cola de atrás hacia adelante, para que se inserten nuevos elementos justo antes del marcador de fin, para que los elementos antiguos se puedan quitar desde el frente, lo que significa que c) tengo que invertir la cola antes de imprimirla.

PHP, 70 bytes

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

C #, 115 bytes +33 bytes para usar

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étodo anónimo que devuelve una lista de enteros después de realizar las operaciones de puesta en cola y retirada de cola. Los enteros negativos se usan para eliminar elementos de la cola.

Programa completo con método no protegido y casos de prueba:

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}

Como entrada, ftoma una lista con 0el elemento "dequeue". Utiliza la recursividad de cola con un segundo parámetro ( b), que actúa como un acumulador. Inicialmente, bes el vacío Seq( Nil).

Explicaciones:

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

Nota: b dropRight 1 se utiliza en lugar de b.taila excepción evite: tail of empty list.

Casos de prueba :

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)

fTambién puede funcionar con otros tipos ( String, char, ..., incluso heterogénea lista de esos tipos!):

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

Toma una cadena separada por espacios, imprime una cadena separada por espacios

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 indica una cola.

Pruébalo en línea!

Swift 3, 70 bytes

Asumiendo que tenemos una serie de Ints como let x = [1, 2,-1,3,-1,4]

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

Tenga en cuenta que [].prefix(0)es una forma furtiva de obtener un ArraySlice vacío