Виклик

Подаючи список цілих чисел, поверніть список цих цілих чисел після багаторазового видалення всіх пар сусідніх рівних елементів.

Зауважте, що якщо у вас пробіжка непарної довжини рівних чисел, одна з них залишиться, не входячи в пару.

Приклад:

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

Оцінка балів

Це код-гольф , тому найкоротша відповідь на кожній мові виграє!

Желе , 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$¶?

Спробуйте в Інтернеті!

Збережено 2 байти завдяки Нілу та Мартіну!

Кожна пара чисел замінює нічим. Цей процес циклічно, поки не буде внесено змін.

Mathematica 29 байт

Це неодноразово видаляє пари рівних сусідніх елементів, a_,a_поки не залишиться жодного.

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

Python 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 байт завдяки милям і виправлено :)

JavaScript (ES6), 54 53 байти

Збережено 1 байт завдяки @ThePirateBay

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

Наївне рекурсивне рішення, може бути неймовірним.

Python 2 , 73 байти

Оскільки у мене недостатньо репутації для коментарів: я просто змінив відповідь @officialaimm на використання r! = [] Замість len (r), щоб зберегти байт. Дуже розумне рішення для вас, @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, масиви фактично представлені в мові як вказівник на перший елемент і довжину . Єдине, що тут трохи дивно - це взяти довжину за посиланням , але якби ми цього не зробили, не було б способу скоротити масив. Код буде добре працювати, але вихід міститиме сміття, оскільки абонент не знатиме, де зупинити друк елементів із згорнутого масиву.

Невикольована збірна мнемоніка:

; 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-бітний захищений режим, зокрема, "плоску" модель пам'яті, де додатковий сегмент ( 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, .тому що Batch плутається, якщо є лише дублікати. Я також повинен використовувати, 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)

Japt , 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)

Haskell , 33 байти

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

Спробуйте в Інтернеті!

Python 2 , 74 70 66 байт

• Дякую @SteamyRoot за 4 байти: rзамість цього len(r)достатньо, щоб перевірити порожнечу списку / стека.
• Дякую @ovs за 4 байти: краще за умови [i]==r[-1:]

Python 2 , 66 байт

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

Спробуйте в Інтернеті!

Clojure, 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 байт

òͨ.«©î±î*

Спробуйте в Інтернеті!

Стиснутий Regex: :%s/\(.\+\)\n\1\n*. Необов’язковий новий рядок є таким, що він також працює в кінці файлу. Якщо я припускаю, що після закінчення є новий рядок, це буде 8 байт ... але це здається розтяжкою

постійного струму , 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і копіює його в реєстр, xперш ніж перевірити, щоб переконатися, що yце ненульовий (тобто стек .має дані). Якщо це так, він запускає макрос A. Нарешті він перевіряє, чи є вихідний розмір стека більше, ніж поточний розмір стека, і відновлює себе, якщо так. Після закінчення він друкує стекf .
• [dStrdStr!=Pz1<O]sOМакрос Oтимчасово зберігає два верхні елементи в стеку в стек t. Потім вона порівнює два перших пункту та запускає макросP якщо вони не рівні. Нарешті він перевіряє, чи є принаймні два елементи на стеку, і запускається сам, якщо так.
• [LtLtS.ly1+sy]sPМакрос Pвиймає два елементи із стека t, верхній повертає назад на основний стек і висуває наступний на стек .. Потім він збільшує лічильник 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>посилання, модифікує її на місці, щоб згортати сусідні дублікати відповідно до специфікації, а потім повертає.

Спробуйте в Інтернеті!

Перш ніж перевірити кількість байтів, я подумав, що це досить svelte-код. Більше 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 байт

+1 байт для -rпрапора.

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

Спробуйте в Інтернеті!

Pyth, 10 байт

Трохи спізнившись на вечірку.

ueMf%hT2r8

Тестовий сюїт.