소개

큐 요소가되는 추상 데이터 유형 전면에 추가 (인큐) 및 후면으로부터 제거 (디큐). 이것을 FIFO (First In First Out) 원칙 이라고도합니다 .

예를 들어 가장 잘 나타납니다.

도전

양의 정수 와 요소 (요소 제거) 를 나타내는 요소 를 포함하는 비어 있지 않은 배열이 주어지면 큐 의 최종 목록을 출력하십시오.

X이 예제에서 dequeue 를 나타냅니다. 다음 목록을 살펴 보겠습니다.

[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 이므로 바이트 수가 가장 적은 제출이 승리합니다!

젤리 , 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.

파이썬 2, 56 53 50 바이트

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

온라인으로 사용해보십시오!

큐잉은 -1입니다. 이 트릭을 사용하면 대기열을 쉽게 pythonic 슬라이싱 할 수 있습니다.

수학, 102 바이트

확실히 가장 짧은 해결책은 아니지만 일종의 왜곡되어 저항 할 수 없었습니다.

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

일부 도우미 함수 후에는 문자열을 입력으로 사용하는 순수한 함수를 정의합니다. 문자열에서 숫자는 쉼표로 구분됩니다 (공백은 선택 사항 임). dequeue character는 "]"; 목록의 앞뒤에 구분 기호가 없습니다. 예를 들어 OP의 첫 번째 예는 string으로 입력됩니다 "45,],],37,20,],97,],85". 함수의 출력은 숫자 목록입니다.

이 함수는 "]"입력 문자열에있는 대기열의 수를 세고 문자열 "f["의 앞에 많은 사본을 추가 한 다음 전체를로 묶습니다 "r[...]". 위의 예에서 이것은 "r[f[f[f[f[45,],],37,20,],97,],85]"; 브래킷이 균형을 이룹니다.

그런 다음 ToExpression결과 문자열을 Mathematica 코드의 일부로 해석하여 실행합니다. 이 함수 f는 첫 번째를 제외하고 모든 인수를 유지하도록 편리하게 정의되며 후행 쉼표는 무시합니다. 어쨌든 빈 큐 큐를 처리하는 데 필요합니다. r결과 시퀀스를 올바른 순서로 숫자 목록으로 변환합니다.

망막 , 30 바이트

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

온라인으로 사용해보십시오!

첫 번째 숫자 (반드시 반드시 그런 것은 아님) 다음에 그 X와 함께 X또는 X문자열의 시작 부분에있는 숫자를 반복해서 제거 합니다. 그런 다음 나머지 숫자를 되돌립니다.

자바 스크립트, 70 63 53 50 43 바이트

for 루프 및 삼항식 대신 x.map을 사용하여 10 바이트를 골라내어 주셔서 감사합니다.

3 바이트를 골라 낸 @Arnauld에게 감사합니다.

7 바이트 오프 골프를위한 @ETHproductions에게 감사합니다

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

온라인으로 사용해보십시오!

대기열에서 제외는 true 이외의 숫자가 아닌 값일 수 있습니다.

매스 매 티카, 46 45 바이트

1 바이트 저장을위한 ngenisis 덕분입니다.

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

기본적으로 패턴 일치를 사용하는 Retina 답변과 동일합니다. X첫 번째 숫자를 반복해서 일치시키고 첫 번째 숫자와 함께 제거합니다 (있는 경우). 완료되면 목록을 반대로 바꿉니다.

순수한 배쉬, 72

명령 행 매개 변수로 제공된 입력

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

온라인으로 사용해보십시오 .

하스켈, 41 바이트

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

MATL , 13 12 바이트

vi"@?@wh}IL)

입력은 0"dequeue" 와 함께 숫자의 배열입니다 .

출력은 공백으로 구분 된 숫자입니다. 빈 결과는 아무것도 표시되지 않습니다.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

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)

하스켈, 41 40 바이트

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

기능은 foldl(#)[](사이에 바이트가 분리 된 바이트 수에도 포함됨)

온라인으로 사용해보십시오!

X는 양수가 아닌 정수입니다.

편집 : nimi 덕분에 -1 바이트

Julia, 78 76 73 57 바이트

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

Julia 골프 제안에 대한 해리슨 그 로딘에게 감사드립니다. 16 바이트를 절약하기 위해 if / else를 3 진으로, for / end를 목록 이해로 대체했습니다.

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

3 바이트를 절약하기 위해 불필요한 공간을 제거했습니다.

음수 또는 0이 허용되기 전에 :

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

언 골프 드 :

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를 처음 접했습니다. 더 좋은 방법이있을 수 있습니다. :XJulia의 기호 인 X에 사용 합니다. 업데이트 : 이제 0이 허용되므로 X에 0 (또는 음수)을 사용하여 두 문자를 저장하십시오. 내가 알지 못했던 공백을 제거하기 위해 다시 업데이트되었습니다.

05AB1E , 12 11 바이트

라일리 덕분에 바이트를 절약

)Evyai¨ëy¸ì

온라인으로 사용해보십시오!

설명

대기열에서 제외는 문자 로 표시됩니다 .

)             # 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 세드, 43

점수는 -rand -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

PHP, 85 바이트

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

모든 큐 값이 false에 속하는 경우 $v대신 -8 바이트is_int($v)

파이썬 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])

펄 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

  온라인으로 사용해보십시오!

파이썬 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는 숫자가 아닌 값이 될 수 있습니다.

온라인으로 사용해보십시오

배치, 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%

이것은 필요 이상으로 힘들었습니다.

• Batch는 문자열 분할 결과를 열거 할 수 있지만 열거에서 요소를 쉽게 제거 할 수는 없습니다.
• 첫 번째 항목을 제거 할 수 있지만 하나 이상의 항목이있는 경우에만 가능합니다. 그렇지 않으면 쓰레기가 나옵니다.

즉, a) 대기열 끝 마커가 없어야하며 제거되지 않아야합니다. b) 대기열을 앞뒤로 조작해야 새 항목이 끝 마커 바로 앞에 삽입됩니다. 따라서 오래된 항목을 전면에서 제거 할 수 있으므로 I c) 인쇄하기 전에 대기열을 뒤집어 야합니다.

PHP, 70 바이트

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

C #, 115 바이트 +33 바이트

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

큐잉 및 큐잉 제거 작업을 수행 한 후 정수 목록을 리턴하는 익명 메소드. 음수는 큐에서 요소를 제거하는 데 사용됩니다.

ungolfed 방법 및 테스트 사례가 포함 된 전체 프로그램 :

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

스칼라, 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.tailtail 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, !)

REXX, 115 바이트

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

공백으로 구분 된 문자열을 가져오고 공백으로 구분 된 문자열을 인쇄합니다

C ++, 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은 대기열에서 제외됨을 나타냅니다.

온라인으로 사용해보십시오!

스위프트 3, 70 바이트

다음과 같은 Int 배열이 있다고 가정합니다. 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)빈 ArraySlice을 얻을 수있는 비열한 방법입니다