Reto

Dada una lista de enteros, devuelva la lista de estos enteros después de eliminar repetidamente todos los pares de elementos iguales adyacentes.

Tenga en cuenta que si tiene una serie de números iguales de longitud impar, uno de ellos permanecerá y no formará parte de un par.

Ejemplo:

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

En primer lugar, se debe eliminar 0, 0, 4, 4y 1, 1para obtener:

[0, 1, 2, 2, 0]

Ahora, debes eliminar 2, 2:

[0, 1, 0]

Y este es el resultado final.

Casos de prueba

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

Tanteo

Este es el código de golf , por lo que gana la respuesta más corta en cada idioma.

Jalea , 10 bytes

Œgœ^/€FµÐL

Pruébalo en línea!

Cómo funciona

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

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

Pruébalo en línea!

¡Ahorré 2 bytes gracias a Neil y Martin!

Reemplaza cada par de números con nada. Este proceso se repite hasta que no se realizan cambios.

Mathematica 29 bytes

Esto elimina repetidamente pares de elementos adyacentes iguales, a_,a_hasta que no quede ninguno.

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

Python 2 , 57 bytes

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

Pruébalo en línea!

Construye iterativamente la lista de salida agregando el siguiente elemento, luego cortando el final si el elemento anexado es igual al anterior. Verificar el penúltimo elemento r[-2:-1]!=[x]resulta incómodo porque es posible que la lista tenga una longitud de solo 1.

Jalea , 15 bytes

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

Pruébalo en línea!

Explicación

Œ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 gracias a millas, y arreglado :)

JavaScript (ES6), 54 53 bytes

Guardado 1 byte gracias a @ThePirateBay

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

Solución recursiva ingenua, puede ser mejorable.

Python 2 , 73 bytes

Como no tengo suficiente reputación para comentar: acabo de cambiar la respuesta de @officialaimm para usar r! = [] En lugar de len (r) para guardar un byte. ¡Una solución muy inteligente para ti, @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

Pruébalo en línea!

Es, de nuevo, demasiado tarde ... ¿por qué aún estoy despierto?

Python, 60 58 bytes

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

Pruébalo en línea!

MATL , 7 bytes

t"Y'oY"

Para algunos de los casos de prueba donde el resultado está vacío, el programa sale con un error, pero en cualquier caso produce la salida correcta (vacía).

Pruébalo en línea! O verifique los casos de prueba con salida no vacía .

Explicación

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

Considerar entrada

0 0 0 1 2 4 4 2 1 1 0

Cada iteración elimina pares de pares consecutivos. La primera iteración reduce la matriz a

0 1 2 2 0

Los dos valores 2que ahora son adyacentes no eran adyacentes en la matriz inicial. Es por eso que se necesita una segunda iteración, que da:

0 1 0

Otras iteraciones dejarán esto sin cambios. El número de iteraciones requeridas está limitado por el tamaño de entrada.

Un resultado intermedio vacío hace que la función de decodificación de longitud de ejecución ( Y") falle en la versión actual del lenguaje; pero la salida está vacía según sea necesario.

Código de máquina x86 (modo protegido de 32 bits), 36 bytes

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

Los bytes anteriores del código de máquina definen una función que toma una matriz como entrada, contrae duplicados adyacentes en el lugar y regresa a la persona que llama sin devolver un resultado. Sigue la __fastcallconvención de llamada , pasando los dos parámetros en los registros ECXy EDX, respectivamente.

El primer parámetro ( ECX) es un puntero al primer elemento en la matriz de enteros de 32 bits (si la matriz está vacía, puede apuntar a cualquier parte de la memoria). El segundo parámetro ( EDX) es un puntero a un entero de 32 bits que contiene la longitud de la matriz.

La función modificará los elementos de la matriz en el lugar, si es necesario, y también actualizará la longitud para indicar la nueva longitud de la matriz contraída. Este es un método un poco inusual para tomar entradas y devolver salidas, pero realmente no tiene otra opción en lenguaje ensamblador. Como en C, las matrices se representan realmente en el lenguaje como un puntero al primer elemento y una longitud . Lo único un poco extraño aquí es tomar la longitud por referencia , pero si no lo hiciéramos, no habría forma de acortar la matriz. El código funcionaría bien, pero el resultado contendría basura, porque la persona que llama no sabría dónde detener la impresión de elementos desde la matriz contraída.

Mnemónicos de ensamblaje sin golf:

; 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

La implementación fue inspirada por mi respuesta de C ++ 11 , pero se reescribió meticulosamente en el ensamblaje, optimizando el tamaño. El ensamblaje es un lenguaje de golf mucho mejor. :-)

Nota: Debido a que este código utiliza las instrucciones de cadena, es no asumir que el indicador de dirección es clara ( DF== 0). Esta es una suposición razonable en la mayoría de los entornos operativos, ya que el ABI generalmente requiere que el DF sea claro. Si esto no se puede garantizar, entonces se debe insertar una CLDinstrucción de 1 byte ( 0xFC) en la parte superior del código.

También, como se señaló, asume el modo protegido de 32 bits, específicamente, un modelo de memoria "plano", donde el segmento adicional ( ES) es el mismo que el segmento de datos ( DS).

Lote, 133 bytes

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

Configuré s .porque Batch se confunde si solo hay duplicados. También tengo que usar shift/1para %0%s:~1%poder configurar la lista de argumentos en la nueva matriz y bucle.

Jalea , 12 bytes

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

Un enlace monádico que toma y devuelve listas de números.

Pruébalo en línea! o ver un conjunto de pruebas

¿Cómo?

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

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

Recurrentemente elimina pares de números iguales hasta que no exista ninguno.

Pruébalo en línea! con el-Q bandera para formatear la matriz de salida.

Ejecute todos los casos de prueba con mi WIP CodePen.

05AB1E , 15 bytes

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

Pruébalo en línea!

Explicación

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

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

Pruébalo en línea!

Explicación:

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

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

Pruébalo en línea!

Pitón 2 , 74 70 66 bytes

• Gracias @SteamyRoot por 4 bytes: r lugar de len(r)es suficiente para verificar el vacío de la lista / pila.
• Gracias @ovs por 4 bytes: mejor si la condición [i]==r[-1:]

Python 2 , 66 bytes

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

Pruébalo en línea!

Clojure, 100 bytes

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

No estoy seguro si esto es lo más corto posible.

Bash, 82 bytes

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

Probablemente hay una salida de todos esos cats, pero no lo sé.

Casco , 10 bytes

ωoṁS↑o%2Lg

Pruébalo en línea!

Explicación

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

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

función, llame por referencia o pruébelo en línea .

falla por entrada vacía; insertar $i&&o $a&&antes --$ide arreglar.

V , 10 bytes

òͨ.«©î±î*

Pruébalo en línea!

Regex comprimido: :%s/\(.\+\)\n\1\n*. La nueva línea opcional es para que también funcione al final del archivo. Si supongo que hay una nueva línea después del final, serían 8 bytes ... pero eso parece un tramo

cc , 84 78 bytes

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

Pruébalo en línea!

Desempacarlo un poco, fuera de orden en algún intento de claridad:

• [0syzdsz1<Olydsx0<Alx1+lz>M]dsMxfLa macro principal Mrestablece el contador ya 0, recupera el número de elementos en la pila, almacena esto en el registro zy luego ejecuta la macro Osi hay al menos dos elementos en la pila. Una vez que Ofinaliza, carga el contador yy lo copia en el registro xantes de verificar para asegurarse de que yno sea cero (lo que significa que la pila .tiene datos). Si este es el caso, se ejecuta macro A. Finalmente, comprueba si el tamaño original de la pila es mayor que el tamaño actual de la pila y, de ser así, se vuelve a ejecutar. Una vez que ha terminado, imprime la pila con f.
• [dStrdStr!=Pz1<O]sOMacro Oalmacena temporalmente los dos elementos superiores en la pila en la pila t. Luego compara los dos primeros elementos y ejecuta macro Psi no son iguales. Finalmente, verifica si hay al menos dos elementos en la pila y se ejecuta solo si es así.
• [LtLtS.ly1+sy]sPMacro Ptoma los dos elementos de la pila t, empuja el superior hacia la pila principal y empuja el siguiente hacia la pila .. Luego incrementa el contador y.
• [L.ly1-dsy0<A]sAMacro Atoma la pila .y la vuelve a convertir en la pila primaria. Lo hace, disminuyendo el contador yhasta que no quede nada más que empujar.

Editado para explicación y para jugar golf de 6 bytes ya que estaba almacenando innecesariamente el tamaño de la pila.

C ++ 11, 161 bytes

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

El código anterior define una función, fque toma una std::vector<int>referencia, la modifica para colapsar los duplicados adyacentes de acuerdo con la especificación, y luego regresa.

Pruébalo en línea!

Antes de verificar el recuento de bytes, pensé que este era un código bastante esbelto. Sin embargo, ¡más de 150 bytes no es tan bueno! O no soy muy bueno jugando al golf, o C ++ no es un lenguaje de golf muy bueno ...

Sin golf:

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

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

La función c llama por referencia para reducir la matriz. Pruébalo en línea .

Curiosamente, esto funciona en Php5.6 pero no en 7.

R , 57 54 bytes

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

Pruébalo en línea!

usa una codificación de longitud de ejecución para eliminar pares.

J , 38 bytes

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

Pruébalo en línea!

GNU sed , 19 + 1 = 20 bytes

+1 byte para -rbandera.

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

Pruébalo en línea!

Pyth, 10 bytes

Un poco tarde para la fiesta.

ueMf%hT2r8

Banco de pruebas.