Thử thách

Đưa ra một danh sách các số nguyên, trả về danh sách các số nguyên này sau khi liên tục xóa tất cả các cặp vật phẩm bằng nhau liền kề.

Lưu ý rằng nếu bạn có một chuỗi số lẻ bằng nhau, một trong số chúng sẽ vẫn còn, không phải là một phần của một cặp.

Thí dụ:

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

Trước tiên, bạn nên loại bỏ 0, 0, 4, 4và 1, 1để có được:

[0, 1, 2, 2, 0]

Bây giờ, bạn nên loại bỏ 2, 2:

[0, 1, 0]

Và đây là kết quả cuối cùng.

Các trường hợp thử nghiệm

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

Chấm điểm

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất trong mỗi ngôn ngữ sẽ thắng!

Thạch , 10 byte

Œgœ^/€FµÐL

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Œ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.

Võng mạc ,17 15 byte

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

Hãy thử trực tuyến!

Đã lưu 2 byte nhờ Neil và Martin!

Thay thế mỗi cặp số không có gì. Quá trình này lặp lại cho đến khi không có thay đổi được thực hiện.

Toán học 29 byte

Điều này liên tục loại bỏ các cặp phần tử liền kề bằng nhau, a_,a_cho đến khi không còn lại.

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

Python 2 , 57 byte

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

Hãy thử trực tuyến!

Lặp lại xây dựng danh sách đầu ra bằng cách nối thêm phần tử tiếp theo, sau đó cắt bỏ phần cuối nếu phần tử nối thêm bằng với phần tử trước nó. Việc kiểm tra phần tử thứ hai đến cuối cùng r[-2:-1]!=[x]trở nên khó xử vì có thể danh sách chỉ có độ dài 1.

Thạch , 15 byte

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

Hãy thử trực tuyến!

Giải trình

Œ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 byte nhờ dặm, và cố định :)

JavaScript (ES6), 54 53 byte

Đã lưu 1 byte nhờ @ThePirateBay

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

Giải pháp đệ quy ngây thơ, có thể là ngẫu hứng.

Python 2 , 73 byte

Vì tôi không đủ danh tiếng để bình luận: Tôi chỉ thay đổi câu trả lời của @officialaimm để sử dụng r! = [] Thay vì len (r) để lưu một byte. Giải pháp rất thông minh cho bạn, @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

Hãy thử trực tuyến!

Đó là, một lần nữa, quá muộn ... tại sao tôi vẫn còn dậy?

Python, 60 58 byte

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

Hãy thử trực tuyến!

MATL , 7 byte

t"Y'oY"

Đối với một số trường hợp kiểm tra trong đó kết quả trống, chương trình thoát có lỗi, nhưng trong mọi trường hợp, nó tạo ra đầu ra (trống) chính xác.

Hãy thử trực tuyến! Hoặc xác minh các trường hợp thử nghiệm với đầu ra không trống .

Giải trình

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

Xem xét đầu vào

0 0 0 1 2 4 4 2 1 1 0

Mỗi lần lặp loại bỏ các cặp liên tiếp. Lặp lại đầu tiên làm giảm mảng

0 1 2 2 0

Hai giá trị 2liền kề không liền kề trong mảng ban đầu. Đó là lý do tại sao cần phải lặp lại lần thứ hai, điều này mang lại:

0 1 0

Lặp đi lặp lại sẽ không thay đổi này. Số lần lặp được yêu cầu được giới hạn trên bởi kích thước đầu vào.

Một kết quả trung gian trống khiến hàm giải mã độ dài chạy ( Y") bị lỗi trong phiên bản hiện tại của ngôn ngữ; nhưng ouput trống rỗng theo yêu cầu.

Mã máy x86 (chế độ được bảo vệ 32 bit), 36 byte

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

Các byte trên của mã máy xác định một hàm lấy một mảng làm đầu vào, thu gọn các bản sao liền kề tại chỗ và trả về cho người gọi mà không trả về kết quả. Nó tuân theo __fastcallquy ước gọi , lần lượt chuyển hai tham số trong ECXvà các EDXthanh ghi.

Tham số đầu tiên ( ECX) là một con trỏ tới phần tử đầu tiên trong mảng các số nguyên 32 bit (nếu mảng trống, nó có thể trỏ bất cứ nơi nào trong bộ nhớ). Tham số thứ hai ( EDX) là một con trỏ tới số nguyên 32 bit chứa độ dài của mảng.

Hàm sẽ sửa đổi các phần tử của mảng tại chỗ, nếu cần và cũng cập nhật độ dài để chỉ ra độ dài mới của mảng bị sập. Đây là một chút của một phương pháp bất thường để lấy đầu vào và trả lại đầu ra, nhưng bạn thực sự không có lựa chọn nào khác trong ngôn ngữ lắp ráp. Như trong C, các mảng thực sự được biểu diễn bằng ngôn ngữ như một con trỏ tới phần tử đầu tiên và độ dài . Điều duy nhất hơi kỳ lạ ở đây là lấy độ dài bằng cách tham chiếu , nhưng nếu chúng ta không làm điều đó, sẽ không có cách nào để rút ngắn mảng. Mã sẽ hoạt động tốt, nhưng đầu ra sẽ chứa rác, vì người gọi sẽ không biết nơi dừng các phần tử in từ mảng bị sập.

Ma thuật lắp ráp bất khả xâm phạm:

; 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

Việc thực hiện được lấy cảm hứng từ câu trả lời C ++ 11 của tôi , nhưng được viết lại một cách tỉ mỉ trong lắp ráp, tối ưu hóa kích thước. Hội là một ngôn ngữ chơi golf tốt hơn nhiều. :-)

Lưu ý: Bởi vì mã này sử dụng các hướng dẫn chuỗi, là không cho rằng lá cờ hướng rõ ràng ( DF== 0). Đây là một giả định hợp lý trong hầu hết các môi trường hoạt động, vì ABI thường yêu cầu DF rõ ràng. Nếu điều này không thể được đảm bảo, thì một lệnh 1 byte CLD( 0xFC) cần được chèn vào đầu mã.

Nó cũng, như đã lưu ý, giả định cụ thể là chế độ được bảo vệ 32 bit, một mô hình bộ nhớ "phẳng", trong đó phân đoạn phụ ( ES) giống như phân đoạn dữ liệu ( DS).

Mẻ, 133 byte

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

Tôi đặt s thành .vì Batch bị lẫn lộn nếu chỉ có các bản sao. Tôi cũng phải sử dụng shift/1để tôi có thể sử dụng %0%s:~1%để đặt danh sách đối số thành mảng và vòng lặp mới.

Thạch , 12 byte

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

Một liên kết đơn lấy và trả về danh sách các số.

Hãy thử trực tuyến!hoặc xem một bộ thử nghiệm

Làm sao?

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

Japt , 34 byte

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

Loại bỏ đệ quy các cặp số bằng nhau cho đến khi không tồn tại.

Hãy thử trực tuyến! với -Qcờ để định dạng mảng đầu ra.

Chạy tất cả các trường hợp thử nghiệm bằng WIP CodePen của tôi.

05AB1E , 15 byte

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

Hãy thử trực tuyến!

Giải trình

[γʒ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 byte

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

Hãy thử trực tuyến!

Giải trình:

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

Haskell , 33 byte

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

Hãy thử trực tuyến!

Python 2 , 74 70 66 byte

• Cảm ơn @SteamyRoot cho 4 byte: rthay vìlen(r) đủ để kiểm tra sự trống rỗng của danh sách / ngăn xếp.
• Cảm ơn @ovs cho 4 byte: tốt hơn nếu có điều kiện [i]==r[-1:]

Python 2 , 66 byte

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

Hãy thử trực tuyến!

Clojure, 100 byte

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

Không chắc chắn nếu điều này là ngắn nhất có thể.

Bash, 82 byte

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

Có lẽ có một lối thoát cho tất cả những người đó cat, nhưng tôi không biết điều đó.

Husk , 10 byte

ωoṁS↑o%2Lg

Hãy thử trực tuyến!

Giải trình

ω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 byte

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

chức năng, gọi bằng cách tham khảo hoặc thử trực tuyến .

thất bại cho đầu vào trống rỗng; chèn $i&&hoặc $a&&trước --$iđể sửa chữa.

V , 10 byte

òͨ.«©î±î*

Hãy thử trực tuyến!

Regex nén : :%s/\(.\+\)\n\1\n*. Dòng mới tùy chọn là để nó hoạt động ở cuối tập tin. Nếu tôi giả sử rằng có một dòng mới sau khi kết thúc thì nó sẽ là 8 byte ... nhưng dường như đó là một đoạn

dc , 84 78 byte

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

Hãy thử trực tuyến!

Giải nén nó một chút, không theo thứ tự trong một số nỗ lực rõ ràng:

• [0syzdsz1<Olydsx0<Alx1+lz>M]dsMxfMacro chính Mđặt lại bộ đếm yvề 0, lấy số lượng vật phẩm trên ngăn xếp, lưu trữ này trong thanh ghi z, sau đó chạy macro Onếu có ít nhất hai vật phẩm trên ngăn xếp. Sau khi Okết thúc, nó tải bộ đếm yvà sao chép nó vào thanh ghi xtrước khi kiểm tra để chắc chắn ylà khác không (có nghĩa là ngăn xếp .có dữ liệu). Nếu đây là trường hợp, nó chạy macro A. Cuối cùng, nó kiểm tra xem kích thước ngăn xếp ban đầu có lớn hơn kích thước ngăn xếp hiện tại hay không và tự chạy lại nếu có. Khi nó đã hoàn thành, nó in ngăn xếp vớif .
• [dStrdStr!=Pz1<O]sOMacro Otạm thời lưu trữ hai mục trên cùng vào ngăn xếp thành ngăn xếp t. Sau đó, nó so sánh hai mục hàng đầu và chạy macro Pnếu chúng không bằng nhau. Cuối cùng, nó kiểm tra xem có ít nhất hai mục trên ngăn xếp hay không và tự chạy nếu có.
• [LtLtS.ly1+sy]sPMacro Plấy hai mục từ ngăn xếp t, đẩy mục trên cùng trở lại ngăn xếp chính và đẩy mục sau vào ngăn xếp .. Sau đó tăng số lượt truy cập y.
• [L.ly1-dsy0<A]sAMacro Alấy stack .và biến nó trở lại stack chính. Nó làm điều đó, giảm số lượt truy cập ycho đến khi không còn gì để đẩy.

Đã được chỉnh sửa để giải thích và để loại bỏ 6 byte khi tôi không cần lưu trữ kích thước của ngăn xếp.

C ++ 11, 161 byte

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

Đoạn mã trên xác định một hàm, flấy std::vector<int>tham chiếu, sửa đổi nó tại chỗ để thu gọn các bản sao liền kề theo đặc tả và sau đó trả về.

Hãy thử trực tuyến!

Trước khi tôi kiểm tra số byte, tôi nghĩ rằng đây là mã khá mảnh dẻ. Hơn 150 byte, tuy nhiên, không tốt lắm! Hoặc là tôi không giỏi chơi gôn, hoặc C ++ không phải là một ngôn ngữ chơi golf rất tốt

Ung dung:

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

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

Hàm c gọi theo tham chiếu để giảm mảng. Hãy thử trực tuyến .

Điều thú vị là nó hoạt động trong Php5.6 chứ không phải 7.

R , 57 54 byte

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

Hãy thử trực tuyến!

sử dụng mã hóa độ dài chạy để loại bỏ các cặp.

J , 38 byte

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

Hãy thử trực tuyến!

GNU sed , 19 + 1 = 20 byte

+1 byte cho -rcờ.

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

Hãy thử trực tuyến!

Bình thường, 10 byte

Bit đến bữa tiệc muộn.

ueMf%hT2r8

Phòng thử nghiệm.