Meydan okuma

Bir tamsayı listesi verildiğinde, tüm bitişik eşit öğelerin çiftlerini art arda çıkardıktan sonra bu tamsayıların listesini döndür.

Eğer bir tuhaf uzunluktaki eşit sayılara sahipseniz, bunlardan birinin bir çiftin parçası olarak kalmayacağını unutmayın.

Örnek:

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

Öncelikle kaldırmak gerekir 0, 0, 4, 4ve 1, 1almak için:

[0, 1, 2, 2, 0]

Şimdi çıkarmanız gerekir 2, 2:

[0, 1, 0]

Ve bu nihai sonuçtur.

Test Kılıfları

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

puanlama

Bu kod golf , yani her dilde en kısa cevap kazanır!

Jöle , 10 bayt

Œgœ^/€FµÐL

Çevrimiçi deneyin!

Nasıl çalışır

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

retina ,17 15 bayt

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

Çevrimiçi deneyin!

Neil ve Martin sayesinde 2 bayt kurtarıldı!

Her sayı çiftini hiçbir şey olmadan değiştirir. Bu işlem hiçbir değişiklik yapılmayana kadar döngüye girer.

Mathematica 29 bayt

Bu a_,a_, hiç kimse kalmayana kadar eşit bitişik eleman çiftlerini tekrar tekrar kaldırır .

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

Python 2 , 57 bayt

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

Çevrimiçi deneyin!

Çıktı listesini sonraki öğeyi ekleyerek sırayla oluşturur, ardından ekleyen öğenin öncekine eşit olması durumunda sona erdirilir. İkinci-son elemanın kontrol edilmesi r[-2:-1]!=[x]zorlaşır çünkü listenin sadece 1 uzunluğu vardır.

Jöle , 15 bayt

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

Çevrimiçi deneyin!

açıklama

Œ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 bayt mil sayesinde ve düzeltildi :)

JavaScript (ES6), 54 53 bayt

@ThePirateBay sayesinde 1 bayt kaydedildi

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

Saf özyinelemeli çözüm, geliştirilebilir olabilir.

Python 2,73 bayt

Yorum yapacak kadar itibarımız olmadığından: @officialaimm 'in yanıtını bir bayt kaydetmek için len (r) yerine r! = [] Yerine değiştirdim. Size çok zekice bir çözüm, @ 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

Çevrimiçi deneyin!

Yine, çok geç ... neden hala ayaktayım?

Python, 60 58 bayt

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

Çevrimiçi deneyin!

MATL , 7 bayt

t"Y'oY"

Sonucun boş olduğu bazı test durumlarında program bir hatayla çıkıyor, ancak her durumda doğru (boş) çıktı üretiyor.

Çevrimiçi deneyin! Veya boş durumda çıktı ile test durumlarını doğrulayın .

açıklama

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

Girişi düşünün

0 0 0 1 2 4 4 2 1 1 0

Her yineleme ardışık çiftleri kaldırır. İlk yineleme diziyi indirir.

0 1 2 2 0

2Şimdi bitişik olan iki değer ilk dizide bitişik değildi. Bu nedenle, ikinci bir yinelemeye ihtiyaç duyulmaktadır:

0 1 0

Daha fazla yineleme bu değişmeden bırakacaktır. Gerekli yineleme sayısı giriş boyutu tarafından üst sınırlandırılmıştır.

Boş bir ara sonuç, çalışma uzunluğu kod çözme işlevinin ( Y") dilin geçerli sürümünde hatalı olmasına neden olur ; ancak çıkış gerektiği gibi boştur.

x86 Makine Kodu (32 bit korumalı mod), 36 bayt

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

Makine kodunun yukarıdaki baytları, diziyi girdi olarak alan, bitişik kopyaları yerinde daraltan ve bir sonuç döndürmeden arayana geri dönen bir işlevi tanımlar. Sırasıyla iki parametreyi ve kayıtları kaydeden __fastcallarama kuralını izler .ECXEDX

İlk parametre ( ECX), 32 bit tam sayılar dizisindeki ilk öğeye bir işaretçidir (dizi boşsa bellekte herhangi bir yere işaret edebilir). İkinci parametre ( EDX), dizinin uzunluğunu içeren 32-bit bir tamsayı için işaretçidir.

İşlev, gerektiğinde yerinde dizinin öğelerini değiştirecek ve ayrıca daraltılmış dizinin yeni uzunluğunu belirtmek için uzunluğu güncelleyecektir. Bu, girdi almak ve çıktıyı döndürmek için alışılmadık bir yöntemdir, ancak assembly dilinde gerçekten başka bir seçeneğiniz yok. C'de olduğu gibi, diziler aslında dilde birinci öğeye ve bir uzunluğa işaretçi olarak temsil edilir . Burada tuhaf olan tek şey, uzunluğu referansa göre almak , ancak bunu yapmazsak, diziyi kısaltmanın bir yolu olmazdı. Kod iyi çalışır, ancak çıktı çöp içerir, çünkü arayan kişi daraltılmış dizideki yazdırma öğelerini nerede durduracağını bilemez.

Ungolfed montaj anımsatıcıları:

; 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

Uygulama benim C ++ 11 cevabımdan esinlenildi , ancak montaj için titizlikle yeniden yazılarak boyut için optimize edildi. Meclis çok daha iyi bir golf dilidir. :-)

Not: Bu kod dizesi talimatları kullandığı için olduğu vermez yön bayrak (net olduğunu varsayalım DF== 0). Bu, çoğu işletim ortamında makul bir varsayımdır, çünkü ABI tipik olarak DF'nin açık olmasını gerektirir. Bu garanti edilemezse, kodun başına bir 1 bayt CLDkomut ( 0xFC) eklenmesi gerekir.

Ayrıca, belirtildiği gibi, 32-bit korumalı modu (özellikle de, ekstra segmentin ( ES) veri segmentiyle ( DS) aynı olduğu "düz" bir bellek modeli olduğunu varsayar .

Toplu iş, 133 bayt

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

.Sadece kopyalar varsa, Batch'ın kafası karışır diye ayarlarım . Ayrıca argüman listesini yeni diziye ve döngüye ayarlamak için shift/1kullanabilmem %0%s:~1%gerekiyor.

Jöle , 12 bayt

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

Sayı listelerini alıp geri veren monadik bir bağlantı.

Çevrimiçi deneyin! veya bir test odasına bakın

Nası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)

Japt , 34 bayt

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

Hiçbiri varana kadar eşit sayıdaki çiftleri tekrar tekrar kaldırır.

Çevrimiçi deneyin! -Qçıkış dizisini biçimlendirmek için bayrakla işaretleyin.

WIP CodePen'imi kullanarak tüm test durumlarını çalıştırın .

05AB1E , 15 bayt

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

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

Açıklama:

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

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

Çevrimiçi deneyin!

Python 2 , 74 70 66 bayt

• Teşekkürler @SteamyRoot 4 bayt için: rbunun yerine len(r)listenin / yığının boşluğunu kontrol etmek yeterlidir.
• 4 bayt için @ovs @ teşekkürler: durum daha iyi [i]==r[-1:]

Python 2 , 66 bayt

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

Çevrimiçi deneyin!

Clojure, 100 bayt

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

Bu mümkün olan en kısa olup olmadığından emin değil.

Bash, 82 bayt

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

Muhtemelen bütün bunlardan bir çıkış var cat, ama bilmiyorum.

Kabuğu , 10 bayt

ωoṁS↑o%2Lg

Çevrimiçi deneyin!

açıklama

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

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

işlevi, referansı arayın veya çevrimiçi deneyin .

boş giriş için başarısız; düzeltmek için $i&&veya $a&&önce takın --$i.

V , 10 bayt

òͨ.«©î±î*

Çevrimiçi deneyin!

Regex Sıkıştırılmış: :%s/\(.\+\)\n\1\n*. İsteğe bağlı yeni satır, dosyanın sonunda da çalışacak şekildedir. Sonundan sonra yeni bir satır olduğunu kabul edersem, 8 bayt olurdu ... ama bu bir uzatma gibi görünüyor

dc , 84 78 bayt

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

Çevrimiçi deneyin!

Bir miktar netlikle sonuçlandığında, biraz açtıktan sonra:

• [0syzdsz1<Olydsx0<Alx1+lz>M]dsMxfAna makro Msayacı y0'a sıfırlar , yığındaki öğe sayısını alır, bunu kayıt defterinde saklar z, ardından Oyığında en az iki öğe varsa makroyu çalıştırır . İşlem Obittiğinde, sıfır olmadığından emin olmak için kontrol etmeden önce sayacı yükler yve kayıt defterine kopyalar (yani yığında veri vardır). Bu durumda, makroyu çalıştırır . Son olarak, orijinal yığın boyutunun geçerli yığın boyutundan daha büyük olup olmadığını kontrol eder ve öyleyse tekrar başlatır. Tamamlandığında yığını birlikte yazdırır .xy.Af
• [dStrdStr!=Pz1<O]sOMakro O, yığındaki ilk iki öğeyi geçici olarak yığında depolar t. Daha sonra ilk iki öğeyi karşılaştırır ve Peşit değilse makroyu çalıştırır . Son olarak, yığında en az iki öğe olup olmadığını kontrol eder ve öyleyse kendisini çalıştırır.
• [LtLtS.ly1+sy]sPMakro P, iki öğeyi yığından alır, tüstünü ana yığına geri iter ve aşağıdakiini yığına iter .. Daha sonra sayacı artırır y.
• [L.ly1-dsy0<A]sAMakro Ayığını alır .ve birincil yığına geri döndürür. Bunu yapar, yitecek bir şey kalmayıncaya kadar sayacı azaltır .

Açıklama için ve yığın boyutunu saklamak zorunda kalmadan 6 bayt golf oynamak için düzenlendi.

C ++ 11, 161 bayt

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

Yukarıdaki kod bir işlevi tanımlar fbir alır, std::vector<int>bitişik spesifikasyona göre çiftleri ve daha sonra döner daraltmak için yer değiştirir bu referans ile içerilmektedir.

Çevrimiçi deneyin!

Bayt sayısını kontrol etmeden önce, bu oldukça svelte kod olduğunu düşündüm. 150 bayttan fazla, ancak, o kadar iyi değil! Ya golf oynamakta pek iyi değilim ya da C ++ çok iyi bir golf dili değil…

Ungolfed:

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

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

C işlevi, diziyi azaltmak için başvuruya göre çağırır. Çevrimiçi deneyin .

İlginçtir ki, bu Php5.6'da çalışır ancak 7'de değildir.

R , 57 54 bayt

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

Çevrimiçi deneyin!

çiftleri çıkarmak için bir çalışma uzunluğu kodlaması kullanır.

J , 38 bayt

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

Çevrimiçi deneyin!

GNU sed , 19 + 1 = 20 bayt

-rBayrak için +1 bayt .

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

Çevrimiçi deneyin!

Pyth, 10 bayt

Partiye biraz geç kaldım.

ueMf%hT2r8

Test odası.