Défi

Étant donné une liste d'entiers, renvoyez la liste de ces entiers après avoir supprimé à plusieurs reprises toutes les paires d'éléments égaux adjacents.

Notez que si vous avez un nombre impair de longueurs égales, l'un d'eux restera, ne faisant pas partie d'une paire.

Exemple:

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

Tout d' abord, vous devez retirer 0, 0, 4, 4et 1, 1d'obtenir:

[0, 1, 2, 2, 0]

Maintenant, vous devez supprimer 2, 2:

[0, 1, 0]

Et c'est le résultat final.

Cas de test

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

Notation

C'est le code-golf , donc la réponse la plus courte dans chaque langue gagne!

Gelée , 10 octets

Œgœ^/€FµÐL

Essayez-le en ligne!

Comment ça marche

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

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

Essayez-le en ligne!

Sauvegardé 2 octets grâce à Neil et Martin!

Remplace chaque paire de chiffres par rien. Ce processus se boucle jusqu'à ce qu'aucune modification ne soit apportée.

Mathematica 29 octets

Cela supprime à plusieurs reprises des paires d'éléments adjacents égaux, a_,a_jusqu'à ce qu'il n'en reste plus.

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

Python 2 , 57 octets

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

Essayez-le en ligne!

Construit de manière itérative la liste de sortie en ajoutant l'élément suivant, puis en coupant la fin si l'élément ajouté est égal à celui qui le précède. La vérification de l'avant-dernier élément r[-2:-1]!=[x]s'avère maladroite car il est possible que la liste ait une longueur de 1 seulement.

Gelée , 15 octets

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

Essayez-le en ligne!

Explication

Œ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 octet grâce aux miles, et fixe :)

JavaScript (ES6), 54 53 octets

1 octet enregistré grâce à @ThePirateBay

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

Solution récursive naïve, peut être améliorable.

Python 2 , 73 octets

Comme je n'ai pas assez de réputation pour commenter: je viens de changer la réponse de @officialaimm pour utiliser r! = [] Au lieu de len (r) pour enregistrer un octet. Solution très intelligente pour vous, @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

Essayez-le en ligne!

Il est, encore une fois, trop tard ... pourquoi suis-je encore debout?

Python, 60 58 octets

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

Essayez-le en ligne!

MATL , 7 octets

t"Y'oY"

Pour certains des cas de test où le résultat est vide, le programme se termine avec une erreur, mais dans tous les cas, il produit la sortie (vide) correcte.

Essayez-le en ligne! Ou vérifiez les cas de test avec une sortie non vide .

Explication

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

Tenez compte des commentaires

0 0 0 1 2 4 4 2 1 1 0

Chaque itération supprime des paires de paires consécutives. La première itération réduit le tableau à

0 1 2 2 0

Les deux valeurs 2qui sont maintenant adjacentes n'étaient pas adjacentes dans le tableau initial. C'est pourquoi une deuxième itération est nécessaire, ce qui donne:

0 1 0

De nouvelles itérations laisseront cela inchangé. Le nombre d'itérations requises est limité par la taille d'entrée.

Un résultat intermédiaire vide entraîne une Y"erreur de la fonction de décodage de longueur d'exécution ( ) dans la version actuelle du langage; mais la sortie est vide comme requis.

Code machine x86 (mode protégé 32 bits), 36 octets

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

Les octets ci-dessus de code machine définissent une fonction qui prend un tableau en entrée, réduit les doublons adjacents en place et retourne à l'appelant sans renvoyer de résultat. Il suit la __fastcallconvention d'appel , en passant les deux paramètres dans le ECXetEDX registres, respectivement.

Le premier paramètre ( ECX) est un pointeur vers le premier élément du tableau d'entiers 32 bits (si le tableau est vide, il peut pointer n'importe où dans la mémoire). Le deuxième paramètre (EDX ) est un pointeur sur un entier 32 bits qui contient la longueur du tableau.

La fonction modifiera les éléments du tableau sur place, si nécessaire, et mettra également à jour la longueur pour indiquer la nouvelle longueur du tableau réduit. C'est un peu une méthode inhabituelle pour prendre des entrées et retourner des sorties, mais vous n'avez vraiment pas d'autre choix en langage assembleur. Comme en C, les tableaux sont en fait représentés dans le langage comme un pointeur vers le premier élément et une longueur . La seule chose un peu bizarre ici est de prendre la longueur par référence , mais si nous ne le faisions pas, il n'y aurait aucun moyen de raccourcir le tableau. Le code fonctionnerait bien, mais la sortie contiendrait des ordures, car l'appelant ne savait pas où arrêter l'impression des éléments du tableau réduit.

Mnémoniques d'assemblage non golfés:

; 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

L'implémentation a été inspirée par ma réponse C ++ 11 , mais méticuleusement réécrite en assemblage, optimisant pour la taille. L'assemblage est une bien meilleure langue de golf. :-)

Remarque: Étant donné que ce code utilise les instructions de chaîne, il suppose que l'indicateur de direction est vide ( DF== 0). Il s'agit d'une hypothèse raisonnable dans la plupart des environnements d'exploitation, car l'ABI exige généralement que DF soit clair. Si cela ne peut pas être garanti, une CLDinstruction d'un octet ( 0xFC) doit être insérée en haut du code.

Comme indiqué, il suppose également un mode protégé 32 bits, en particulier un modèle de mémoire "plat", dans lequel le segment supplémentaire ( ES) est le même que le segment de données ( DS).

Lot, 133 octets

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

J'ai défini s .car Batch est confus s'il n'y a que des doublons. Je dois également utiliser shift/1pour pouvoir %0%s:~1%définir la liste d'arguments sur le nouveau tableau et la nouvelle boucle.

Gelée , 12 octets

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

Un lien monadique prenant et renvoyant des listes de numéros.

Essayez-le en ligne! ou voir une suite de tests

Comment?

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

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

Supprime récursivement des paires de nombres égaux jusqu'à ce qu'il n'en existe plus.

Essayez-le en ligne! avec le-Q indicateur pour formater le tableau de sortie.

Exécutez tous les cas de test à l' aide de mon WIP CodePen.

05AB1E , 15 octets

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

Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

Explication:

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

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

Essayez-le en ligne!

Python 2 , 74 70 66 octets

• Merci @SteamyRoot pour 4 octets: rau lieu delen(r) c'est suffisant pour vérifier le vide de la liste / pile.
• Merci @ovs pour 4 octets: mieux si la condition [i]==r[-1:]

Python 2 , 66 octets

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

Essayez-le en ligne!

Clojure, 100 octets

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

Je ne sais pas si c'est le plus court possible.

Bash, 82 octets

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

Il y a probablement un moyen de sortir de tous ces cats, mais je ne le sais pas.

Husk , 10 octets

ωoṁS↑o%2Lg

Essayez-le en ligne!

Explication

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

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

fonction, appelez par référence ou essayez-le en ligne .

échoue pour une entrée vide; insérer $i&&ou $a&&avant --$ide fixer.

V , 10 octets

òͨ.«©î±î*

Essayez-le en ligne!

Regex comprimé: :%s/\(.\+\)\n\1\n*. Le retour à la ligne facultatif permet de fonctionner également à la fin du fichier. Si je suppose qu'il y a une nouvelle ligne après la fin, ce serait 8 octets ... mais cela semble être un tronçon

dc , 84 78 octets

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

Essayez-le en ligne!

Déballage un peu, hors service dans une tentative de clarté:

• [0syzdsz1<Olydsx0<Alx1+lz>M]dsMxfLa macro principale Mréinitialise le compteur yà 0, récupère le nombre d'éléments sur la pile, le stocke dans le registre z, puis exécute la macro Os'il y a au moins deux éléments sur la pile. Une fois Oterminé, il charge le compteur yet le copie dans le registre xavant de vérifier pour s'assurery n'est pas nul (ce qui signifie que la pile .contient des données). Si tel est le cas, il exécute une macro A. Enfin, il vérifie si la taille de pile d'origine est supérieure à la taille de pile actuelle et se réexécute si tel est le cas. Une fois terminé, il imprime la pile avec f.
• [dStrdStr!=Pz1<O]sO Macro O stocke temporairement les deux premiers éléments de la pile dans la pile t. Il compare ensuite les deux premiers éléments et exécute une macroP s'ils ne sont pas égaux. Enfin, il vérifie s'il y a au moins deux éléments sur la pile et s'exécute lui-même dans l'affirmative.
• [LtLtS.ly1+sy]sPLa macro Pprend les deux éléments de la pilet , repousse celui du haut sur la pile principale et pousse le suivant sur la pile .. Il incrémente ensuite le compteur y.
• [L.ly1-dsy0<A]sA Macro A prend la pile .et la retourne dans la pile principale. Il fait cela, décrémentant le compteur yjusqu'à ce qu'il n'y ait plus rien à pousser.

Modifié pour explication, et pour jouer au golf sur 6 octets car je stockais inutilement la taille de la pile.

C ++ 11, 161 octets

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

Le code ci-dessus définit une fonction,, fqui prend unstd::vector<int> par référence, la modifie en place pour réduire les doublons adjacents selon la spécification, puis retourne.

Essayez-le en ligne!

Avant de vérifier le nombre d'octets, je pensais que c'était un code assez svelte. Plus de 150 octets, ce n'est pas si bon! Soit je ne suis pas très bon au golf, soit le C ++ n'est pas un très bon langage de golf…

Non 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 octets

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

La fonction c appelle par référence pour réduire le tableau. Essayez-le en ligne .

Fait intéressant, cela fonctionne en Php5.6 mais pas 7.

R , 57 54 octets

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

Essayez-le en ligne!

utilise un encodage de longueur pour supprimer les paires.

J , 38 octets

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

Essayez-le en ligne!

GNU sed , 19 + 1 = 20 octets

+1 octet pour le -rdrapeau.

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

Essayez-le en ligne!

Pyth, 10 octets

Un peu tard pour la fête.

ueMf%hT2r8

Suite de tests.