도전

정수 목록이 주어지면 인접한 동일한 항목의 모든 쌍을 반복적으로 제거한 후 이러한 정수 목록을 반환하십시오.

홀수 길이의 같은 수의 런이 있으면 그 중 하나가 쌍의 일부가 아닌 그대로 유지됩니다.

예:

[0, 0, 0, 1, 2, 4, 4, 2, 1, 1, 0]

첫째, 당신은 제거해야합니다 0, 0, 4, 4그리고 1, 1얻을 :

[0, 1, 2, 2, 0]

이제 다음을 제거해야합니다 2, 2.

[0, 1, 0]

그리고 이것이 최종 결과입니다.

테스트 사례

[]-> []
[1]-> [1]
[1, 1]-> []
[1, 2]-> [1, 2]
[11, 11, 11]-> [11]
[1, 22, 1]-> [1, 22, 1]
[-31, 46, -31, 46]-> [-31, 46, -31, 46]
[1, 0, 0, 1]-> []
[5, 3, 10, 10, 5]-> [5, 3, 5]
[5, 3, 3, 3, 5]-> [5, 3, 5]
[0, -2, 4, 4, -2, 0]-> []
[0, 2, -14, -14, 2, 0, -1]-> [-1]
[0, 0, 0, 1, 2, 4, 4, 2, 1, 1, 0]-> [0, 1, 0]
[3, 5, 4, 4, 8, 26, 26, 8, 5]-> [3]
[-89, 89, -87, -8, 8, 88]-> [-89, 89, -87, -8, 8, 88]

채점

이것은 code-golf 이므로 각 언어에서 가장 짧은 답변이 이깁니다!

젤리 , 10 바이트

Œgœ^/€FµÐL

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

작동 원리

Œgœ^/€FµÐL  Main link. Argument: A (array)

       µ    Combine all links to the left into a chain.
Œg              Group all adjacent equal items.
    /€          Reduce each group by...
  œ^                symmetric multiset difference.
                In each step, this maps ([], n) to [n] and ([n], n) to [], so the
                group is left with a single item if its length is odd, and no items
                at all if its length if even.
      F         Flatten the resulting array of singleton and empty arrays.
        ÐL  Apply the chain until the results are no longer unique. Return the last
            unique result.

망막 ,17 15 바이트

+m`^(.+)¶\1$¶?

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

Neil과 Martin 덕분에 2 바이트를 절약했습니다!

각 숫자 쌍을 아무것도없는 것으로 바꿉니다. 이 프로세스는 변경 사항이 없을 때까지 반복됩니다.

매스 매 티카 29 바이트

이것은 동일한 인접 요소 쌍을 반복적으로 제거합니다. a_,a_ 남은 것이 없을 때까지 .

#//.{b___,a_,a_,c___}:>{b,c}&

파이썬 2 , 57 바이트

r=[]
for x in input():r+=x,;r[-2:]*=r[-2:-1]!=[x]
print r

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

다음 요소를 추가하여 출력 목록을 반복적으로 생성 한 다음 추가 요소가 이전 요소와 같으면 끝을 잘라냅니다. 두 번째부터 마지막까지의 요소를 확인하면 r[-2:-1]!=[x]목록의 길이가 1 일 수 있기 때문에 어색합니다.

젤리 , 15 바이트

Œr;ṪḂ$$€x/€FµÐL

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

설명

Œr;ṪḂ$$€x/€FµÐL  Main Link
Œr               Run-length encode
  ;              Concatenate (?)
       €         For each element
   ṪḂ$$          Is the last element odd?
          €      For each element    // Non-breaking alternative
        x/       Reduce by repeating // for run-length decode
           F     Flatten
            µ    (New monadic link)
             ÐL  Repeat until results are no longer unique

마일 덕분에 -1 바이트, 고정 :)

자바 스크립트 (ES6), 54 53 바이트

@ThePirateBay 덕분에 1 바이트 절약

f=a=>1/a.find(q=>q==a[++i],i=-2)?f(a,a.splice(i,2)):a

순진한 재귀 솔루션은 불가능할 수 있습니다.

파이썬 2 , 73 바이트

언급할만한 평판이 충분하지 않기 때문에 바이트를 저장하기 위해 len (r) 대신 r! = []를 사용하도록 @officialaimm의 대답을 변경했습니다. @officialaimm 당신에게 매우 영리한 솔루션!

r=[]                            # create list that will hold final results. A new list is important because it needs to be removable.
for i in input():               
 if r!=[]and r[-1]==i:r.pop()   # Ensure that we have at least 1 char added to the list (r!=[])... or that the last character of our final result isn't the current character being scanned. If that is, well, remove it from the final list because we do not want it anymore
 else:r+=[i]                    # Shorthand for r.append(i). This adds i to the final result
print r

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

다시 말하지만 너무 늦었습니다. 왜 아직도 일어 났습니까?

파이썬, 60 58 바이트

f=lambda a:a and(a[:1]+f(a[1:]))[2*(a[:1]==f(a[1:])[:1]):]

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

MATL , 7 바이트

t"Y'oY"

결과가 비어있는 일부 테스트 케이스의 경우 프로그램이 오류와 함께 종료되지만 어떤 경우에도 올바른 (빈) 출력이 생성됩니다.

온라인으로 사용해보십시오! 또는 비어 있지 않은 출력으로 테스트 사례를 확인하십시오 .

설명

t     % Implicit input. Duplicate
"     % For each (i.e. do as many times as input size)
  Y'  %   Run-length encode. Gives array of values and array of run lengths
  o   %   Parity, element-wise. Reduces run-lengths to either 0 or 1
  Y"  %   Run-length decode. Gives array of values appearing 0 or 1 times;
      %   that is, removes pairs of consecutive values
      % Implicit end. Implicit display

입력 고려

0 0 0 1 2 4 4 2 1 1 0

각 반복은 연속 쌍 쌍을 제거합니다. 첫 번째 반복은 배열을

0 1 2 2 0

2현재 인접한 두 값 은 초기 배열에서 인접하지 않았습니다. 이것이 두 번째 반복이 필요한 이유입니다.

0 1 0

추가 반복은 변경되지 않습니다. 필요한 반복 횟수는 입력 크기에 의해 상한이됩니다.

빈 중간 결과로 인해 Y"현재 버전의 언어에서 런 렝스 디코딩 함수 ( )가 오류가 발생합니다. 그러나 출력은 필요에 따라 비어 있습니다.

x86 머신 코드 (32 비트 보호 모드), 36 바이트

52
8B 12
8D 44 91 FC
8B F9
8D 71 04
3B F0
77 10
A7
75 F9
83 EF 04
4A
4A
A5
3B F8
75 FB
97
EB E7
58
89 10
C3

위의 바이트의 머신 코드는 배열을 입력으로 취하고 인접한 중복을 제자리에서 접은 다음 결과를 반환하지 않고 호출자에게 반환하는 함수를 정의합니다. __fastcall호출 규칙을 따르고 두 개의 매개 변수를 각각 ECX및 EDX레지스터 에 전달합니다 .

첫 번째 매개 변수 ( ECX)는 32 비트 정수 배열의 첫 번째 요소에 대한 포인터입니다 (배열이 비어 있으면 메모리의 아무 곳이나 가리킬 수 있음). 두 번째 매개 변수 ( EDX)는 배열의 길이를 포함하는 32 비트 정수에 대한 포인터입니다.

이 함수는 필요한 경우 배열 요소를 제자리에서 수정하고 축소 된 배열의 새 길이를 나타내도록 길이를 업데이트합니다. 이것은 입력을 가져오고 출력을 반환하는 특이한 방법이지만 어셈블리 언어에서 다른 선택은 없습니다. C에서와 같이 배열은 실제로 언어에서 첫 번째 요소에 대한 포인터와 길이로 표시 됩니다. 여기서 조금 이상한 점은 참조로 길이 를 취하는 것입니다. .하지만 그렇게하지 않으면 배열을 단축 할 수있는 방법이 없습니다. 코드는 정상적으로 작동하지만 호출자는 축소 된 배열에서 요소 인쇄를 중지 해야하는 위치를 알지 못하기 때문에 출력에 쓰레기가 포함됩니다.

ungolfed 어셈블리 니모닉 :

; void __fastcall CollapseAdjacentDuplicates(int * ptrArray, int * ptrLength);
; ECX = ptrArray              ; ECX = fixed ptr to first element
; EDX = ptrLength
   push  edx                  ; save pointer to the length
   mov   edx, [edx]           ; EDX = actual length of the array
   lea   eax, [ecx+edx*4-4]   ; EAX = fixed ptr to last element 

FindAdjacentPairs:
   mov   edi, ecx             ; EDI = ptr to element A
   lea   esi, [ecx+4]         ; ESI = ptr to element B
FindNext:
   cmp   esi, eax             ; is ptr to element B at end?
   ja    Finished             ; if we've reached the end, we're finished
   cmpsd                      ; compare DWORDs at ESI and EDI, set flags, and increment both by 4
   jne   FindNext             ; keep looping if this is not a pair

; Found an adjacent pair, so remove it from the array.
   sub   edi, 4               ; undo increment of EDI so it points at element A
   dec   edx                  ; decrease length of the array by 2
   dec   edx                  ;  (two 1-byte DECs are shorter than one 3-byte SUB)
RemoveAdjacentPair:
   movsd                      ; move DWORD at ESI to EDI, and increment both by 4
   cmp   edi, eax             ; have we reached the end?
   jne   RemoveAdjacentPair   ; keep going until we've reached the end
   xchg  eax, edi             ; set new end by updating fixed ptr to last element
   jmp   FindAdjacentPairs    ; restart search for adjacent pairs from beginning

Finished:
   pop   eax                  ; retrieve pointer to the length
   mov   [eax], edx           ; update length for caller
   ret

구현은 내 C ++ 11 답변 에서 영감을 얻었습니다. 에서 지만 크기를 최적화하여 어셈블리에서 꼼꼼하게 다시 작성했습니다. 조립은 훨씬 나은 골프 언어입니다. :-)

참고 : 이 코드는 문자열 명령어를 사용하기 때문에,이다 않는 방향 플래그 (분명 가정 DF== 0). ABI에서는 일반적으로 DF가 명확해야하므로 이는 대부분의 운영 환경에서 합리적인 가정입니다. 이것이 보장되지 않으면 1 바이트 CLD명령어 ( 0xFC)를 코드 맨 위에 삽입해야합니다.

또한 언급 한 바와 같이 32 비트 보호 모드, 특히 "플랫 (flat)"메모리 모델을 가정합니다. 여기서 여분의 세그먼트 ( ES)는 데이터 세그먼트 ( DS)와 같습니다.

배치, 133 바이트

@set s=.
:l
@if "%1"=="%2" (shift/1)else set s=%s% %1
@shift/1
@if not "%1"=="" goto l
@if not "%s:~2%"=="%*" %0%s:~1%
@echo(%*

.중복이있는 경우 배치가 혼란 스럽기 때문에 s를 설정했습니다 . 또한 인수 목록을 새 배열 및 루프로 설정하는 데 shift/1사용할 수 있도록 사용해야 %0%s:~1%합니다.

젤리 , 12 바이트

ŒgṁLḂ$$€ẎµÐL

숫자 목록을 가져오고 반환하는 모나드 링크.

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오

방법?

ŒgṁLḂ$$€ẎµÐL - Link: list
         µÐL - perform the chain to the left until no changes occur:
Œg           -   group runs (yield a list of lists of non-zero-length equal runs)
      $€     -   last two links as a monad for €ach run:
     $       -     last two links as a monad:
   L         -       length (of the run)
    Ḃ        -       modulo 2 (1 if odd, 0 if even)
  ṁ          -     mould (the run) like (1 or 0) (yields a list of length 1 or 0 lists)
        Ẏ    -   tighten (make the list of lists into a single list)

apt , 34 바이트

ó¥ k_l vîò k_l É}Ãc
ó¥ l ¥Ul ?U:ß

같은 숫자 쌍이 없을 때까지 재귀 적으로 제거합니다.

온라인으로 사용해보십시오! 와 더불어-Q출력 배열을 형식화 플래그 .

WIP CodePen을 사용하여 모든 테스트 사례 를 실행하십시오 .

05AB1E , 15 바이트

[γʒgÉ}€нÐγ‚€gË#

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

설명

[γʒgÉ}€нÐγ‚€gË#
[               # Start infinite loop
 γ              # Group Array into consecutive equal elements
  ʒgÉ}          # Keep the subarrays with an uneven amount of elements
      €н        # Keep only the first element of each subarray
        Ð       # Triplicate the result on the stack
         γ      # Group the top element into consecutive equal elements
          ‚     # Wrap the top two items of the stack in an array
           €g   # Get the length of each subarray
             Ë# # Break if they are equal
                # Implicit print          

05AB1E , 13 바이트

[DγʒgÉ}€нDŠQ#

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

설명:

[DγʒgÉ}€нDŠQ# Implicit input
[             Start infinite loop
 D            Duplicate
  γ           Split into chunks of equal elements
   ʒ  }       Filter by
    g           Length
     É          Odd? (0=falsy 1=truthy)
       €      Foreach command
        н     Head
         D    Duplicate
          Š   Push c, a, b
           Q  Equal? (0=falsy 1=truthy)
            # Break if true (i.e. equal to 1)

하스켈 , 33 바이트

a!(b:c)|a==b=c
a!b=a:b
foldr(!)[]

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

파이썬 2 , 74 70 66 바이트

• 4 바이트에 대해 @SteamyRoot에게 감사드립니다 : r대신 len(r)목록 / 스택의 공허함을 확인하기에 충분합니다.
• 4 바이트에 대한 @ovs 감사합니다. 조건이 좋을 경우 [i]==r[-1:]

파이썬 2 , 66 바이트

r=[]
for i in input():
 if[i]==r[-1:]:r.pop()
 else:r+=[i]
print r

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

클로저, 100 바이트

#(loop[i % j[]](if(= i j)i(recur(mapcat(fn[p](repeat(mod(count p)2)(last p)))(partition-by + i))i)))

이것이 가장 짧은 지 확실하지 않습니다.

배쉬, 82 바이트

cat>b
while cat b>a
perl -pe 's/(\d+) \1( |$)//g' a>b
! diff a b>c
do :
done
cat a

아마도 그 모든 것에서 벗어날 수있는 방법이 cat있지만 그것을 모르겠습니다.

껍질 , 10 바이트

ωoṁS↑o%2Lg

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

설명

ωoṁS↑o%2Lg
ω           Repeat until fixed point
 o          the following two functions:
         g   a) group adjacent elements
  ṁ          b) map over groups and concatenate:
        L     length of group
     o%2      mod 2
   S↑         take that many elements of group

PHP, 81 바이트

    function f(&$a){for($i=count($a);--$i;)$a[$i]-$a[$i-1]||array_splice($a,$i-1,2);}

기능, 참조로 전화하거나 온라인으로 시도하십시오 .

빈 입력에 실패; 삽입 $i&&하거나 수정 $a&&하기 전에 --$i.

V , 10 바이트

òͨ.«©î±î*

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

압축 정규식 : :%s/\(.\+\)\n\1\n*. 선택적 줄 바꿈은 파일 끝에서도 작동합니다. 마지막에 개행 문자가 있다고 가정하면 8 바이트가됩니다 ...하지만 그것은 스트레칭처럼 보입니다.

dc , 84 78 바이트

[L.ly1-dsy0<A]sA[LtLtS.ly1+sy]sP[dStrdStr!=Pz1<O]sO[0syzdsz1<Oly0<Azlz>M]dsMxf

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

명확성을 기하기 위해 순서에 관계없이 약간의 포장을 풉니 다.

• [0syzdsz1<Olydsx0<Alx1+lz>M]dsMxf기본 매크로는 M카운터 y를 0으로 재설정 하고 스택에서 항목 수를 검색하여이를 레지스터에 저장 z한 다음 O스택에 두 개 이상의 항목이 있으면 매크로를 실행 합니다. 완료되면 O카운터를로드 y하고 레지스터에 복사하여 0이 x아닌지 확인합니다 y(스택 .에 데이터가 있음). 이 경우 매크로를 실행 A합니다. 마지막으로 원래 스택 크기가 현재 스택 크기보다 큰지 확인한 다음 다시 실행됩니다. 완료되면를 사용하여 스택을 인쇄합니다 f.
• [dStrdStr!=Pz1<O]sO매크로 O는 스택의 상위 2 개 항목을 임시로 스택에 저장합니다 t. 그런 다음 상위 두 항목을 비교하고 매크로를 실행합니다.P 같지 않으면 합니다. 마지막으로 스택에 두 개 이상의 항목이 있는지 확인하고 필요한 경우 자체 실행됩니다.
• [LtLtS.ly1+sy]sP매크로 P는 스택에서 두 항목을 가져 와서 t맨 위를 기본 스택으로 다시 밀고 다음 항목을 스택 으로 푸시합니다 .. 그런 다음 counter를 증가시킵니다 y.
• [L.ly1-dsy0<A]sA매크로 A는 스택을 가져 와서 .기본 스택으로 되돌립니다. y아무것도 남지 않을 때까지 카운터를 감소시킵니다 .

설명을 위해 편집하고, 불필요하게 스택 크기를 저장했기 때문에 6 바이트를 사용하지 않았습니다.

C ++ 11, 161 바이트

#include<vector>
#include<algorithm>
using V=std::vector<int>;void f(V&v){V::iterator i;while((i=std::adjacent_find(v.begin(),v.end()))!=v.end())v.erase(i,i+2);}

위의 코드는 함수를 정의합니다.이 함수 는 참조로 f가져 와서 std::vector<int>사양에 따라 인접한 중복 항목을 축소하도록 해당 위치를 수정 한 다음 반환합니다.

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

바이트 수를 확인하기 전에이 코드가 매우 빠르다고 생각했습니다. 그러나 150 바이트 이상은 그렇게 좋지 않습니다! 골프에 능숙하지 않거나 C ++는 골프에 능숙하지 않습니다…

언 골프 드 :

#include <vector>
#include <algorithm>

using V = std::vector<int>;

void f(V& v)
{
   V::iterator i;

   // Use std::adjacent_find to search the entire vector for adjacent duplicate elements.
   // If an adjacent pair is found, this returns an iterator to the first element of the
   // pair so that we can erase it. Otherwise, it returns v.end(), and we stop.
   while ((i=std::adjacent_find(v.begin(), v.end())) != v.end())
   {
        v.erase(i, i+2);   // erase this adjacent pair
   }
}

PHP, 74 바이트

function c(&$a){foreach($a as$k=>$v)$a[$k+1]===$v&&array_splice($a,$k,2);}

함수 c는 배열을 줄이기 위해 참조로 호출합니다. 온라인으로 사용해보십시오 .

흥미롭게도 이것은 Php5.6에서는 작동하지만 7에서는 작동하지 않습니다.

R , 57 54 바이트

l=rle(scan());while(any(x<-!l$l%%2))l=rle(l$v[!x]);l$v

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

런 길이 인코딩을 사용하여 쌍을 제거합니다.

J , 38 바이트

;@(<@($~2|#)/.~0+/\@,}.~:}:)^:(0<#)^:_

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

GNU sed , 19 + 1 = 20 바이트

-r플래그의 경우 +1 바이트

:
s/\b(\S+ )\1//g
t

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

Pyth, 10 바이트

파티에 늦었 어

ueMf%hT2r8

테스트 스위트.