У вас є монета , яка виробляє 0або 1. Але ви підозрюєте, що монета може бути упередженою , це означає, що ймовірність 0(або 1) не обов'язково становить 1/2.

Добре відома процедура «перетворення» Необ'єктивне монету в справедливої монети (тобто для отримання результатів з однаковою ймовірністю), як це було запропоновано фон Неймана, полягає в наступному. Виробляйте (не перекриваючись) блоки двох кидок монети, поки два значення блоку не відрізняються; і виводимо перше значення в цей блок (друге значення також буде зроблено, але для цілей цього виклику ми обираємо перше). Наочно, 1може бути більш імовірно , ніж 0, але 01і 10буде з однаковою ймовірністю.

Наприклад, вхід 1110...буде відкидати перший блок, а потім виробляти 1з другого блоку, ...

Ця процедура дорога , тому що для отримання одного результату витрачається кілька кидків монет.

Змагання

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

Останній блок може бути неповним, якщо кількість вхідних значень непарна. Наприклад, послідовність введення 11111не дала б результату (перші два блоки мають рівні значення, а третій - неповний).

Правила

Вхід може мати будь-яке негативне число значень, не обов'язково додатне чи парне.

Формат введення може бути:

• масив нулів і одиниць;
• рядок нулів і одиниць з додатковим роздільником.

Формат виводу може бути:

• рядок нулів і одиниць, з роздільниками або без них;
• масив нулів і одиниць;
• рядки, що містять один нуль або один, розділені новими рядками;
• будь-який подібний, розумний формат, який відповідає вашій мові.

Код гольфу. Виграє найменше байт.

Тестові справи

Введення та вихід тут вважаються рядками.

Input         -->  Output

'1110'        -->  '1'
'11000110'    -->  '01'
'1100011'     -->  '0'
'00'          -->  ''
'1'           -->  ''
''            -->  ''
'1101001'     -->  '0'
'1011101010'  -->  '1111'

Желе, 6 байт

s2Q€Ṗ€

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

Як це працює

s2Q€Ṗ€  Main link. Argument: S (string)

s2      Split the string into pairs of characters.
  Q€    Deduplicate each pair.
        This removes the second character iff it is equal to the first.
    Ṗ€  Pop each; remove the last character of each pair/singleton.

Сітківка , 16 14 байт

(.)\1|(.)?.
$2

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

Пояснення

Це досить просто. Код визначає єдину підстановку регулярних виразів, яка замінює всі (неперекриваються) збіги (.)\1|(.)?.з будь-якою другою групою, яка була захоплена. Це поєднує три різні випадки в один:

(.)\1 --> <empty>

Якщо дві повторювані цифри рівні, вилучаємо їх із рядка (оскільки група 2 не використовується).

(.).  --> $2

В іншому випадку, якщо ми можемо зіставити два символи, видаліть другий, замінивши їх обох першим. Якщо це не так ?, група опустить:

.     --> <empty>

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

Лабіринт , 21 12 байт

"(. :
""*$,@

Рідкісний приклад компактної програми "Лабіринт", яка також не працює. У |попередній версії було зовсім непотрібно, і видалення її значно зменшило розмір програми. Насправді лабораторія побила Сітківку!

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

Зліва внизу "також може бути пробіл, але наявність у ньому значно спрощує пояснення.

Пояснення

Цей трохи складніше, тому його супроводжують зображення. Але спочатку швидкий ґрунтовник:

• Лабіринт - це двоскладова мова на основі стека. Пам'ять складається з основного стека і допоміжного стека.
• Склади Лабіринту бездонні та заповнені нулями, тому виконання операцій над порожнім стеком не є помилкою.
• На кожному перехресті, де є два або більше шляхів для вказівника, який слід пройти, верхня частина основного стеку перевіряється, щоб визначити, куди йти далі. Негатив - поворот ліворуч, нуль - прямо вперед, а позитив - поворот праворуч. Якщо поворот не вдається, вказівник намагається повернути в іншому напрямку.

Налаштування

Програма починається вгорі зліва " , що не стосується. Потім виконуємо:

(        Decrement a bottom zero to -1. Since -1 is negative we try to turn 
         left at this junction, fail, and turn right instead.
"        No-op junction, turn left
*        Multiply top of stack (-1) with a 0 at bottom of stack, giving 0.
         This makes us go straight ahead at this junction.
$        Bitwise xor (of 0 and 0)

Це залишає стек з єдиним 0 на ньому, що так само добре, як порожньо для цілей Лабіринту.

Читання введення та припинення

,зчитує знак із введення, повертаючи 48 або 49 для 0або1 відповідно, і -1 на EOF. Оскільки це не нульове значення, то в будь-якому випадку ми перетворюємось на той :, що дублює верхню частину стека.

Це :знаходиться в глухому куті, тому ми ще раз обертаємось і виконуємо ,. Тепер, якщо останнім входом був EOF, ми повертаємо ліворуч і закінчуємо з @, інакше повертаємо праворуч, при цьому стек виглядає так [a a b](де a,b дві символи).

Інтерпретація кидання монети

Якщо ми не припинили, наступний наш крок - виконувати $(побітовий xor) знову. Це дає 0, якщо вхідні показники були однаковими, 1 в іншому випадку. Потім множимо aцей результат, даючи або 0, або a. Починаючи з* знаходиться на стику, це значення верхнього стека визначає, що буде далі.

У випадку 0 ми йдемо прямо вперед і виконуємо три "відсутності, перш ніж виконати (декремент. Як і налаштування, це змушує нас повертатись та виконувати "*$, залишаючи нас готовими читати більше символів.

В іншому aвипадку ми на повороті повертаємо право, оскільки aє позитивним (48 або 49). .виводить char, залишаючи стек порожнім, і (зменшує верхню частину стека, перетворюючи 0 на -1. Знову ж таки, це змушує нас повернути ліворуч, виконуючи, "*$як у налаштуваннях, а також залишає нас готовими прочитати більше інформації.

CJam, 10 8 байт

l2/{)-}%

Перевірте це тут.

Пояснення

Це дуже просте рішення: у кожній парі видаліть усі екземпляри останнього символу. Повторні цифри та непарні кінцеві цифри будуть видалені, як і друга цифра в будь-якій парі нерівних цифр:

"0"  --> ""
"1"  --> ""
"00" --> ""
"01" --> "0"
"10" --> "1"
"11" --> ""

Це залишає лише цифри, які ми шукаємо. Ось як розраховується код:

l     e# Read input.
2/    e# Split into pairs. Odd inputs will yield a single-character string at the end.
{     e# Map this block over the pairs...
  )   e#   Pull the last character off the string.
  -   e#   Remove all occurrences of that character from the remainder (which is either
      e#   an empty string to begin with or a single-digit string).
}%

Коли список автоматично роздруковується в кінці програми, порожні рядки просто опускаються.

Perl, 19 18 17 байт

Рішення @Martin Büttner Retina надихнуло 2 байт

Включає +1 для -p

Запустити з введенням STDIN, наприклад perl -p fair.pl <<< 11000110

fair.pl:

s/(.)\1|.?\K.//g

Тут мало що пояснювати, оскільки це (непрямий) переклад специфікації:

• (.)\1 Якщо перші 2 цифри однакові, опустіть їх
• .\K. Інакше перші дві цифри різні. Тримайте ( \K) першу
• .?\K.За винятком того, що перший .є необов’язковим. Це дозволяє провести один матч у кінці рядка, який потім відкидається, оскільки збережена частина порожня

Математика, 36 38 байт

-2 після викрадення функції @ LegionMammal978 для визначення того, чи є двоелементний список {0,1} або {1,0}

#&@@@Select[#~Partition~2,Tr@#==1&]&

Очікується, що аргумент буде списком цілих чисел.

Шестикутник , 23 21 байт

,){,/;(_\/'%<\{)/>~$>

Розгорнуто:

    , ) { ,
   / ; ( _ \
  / ' % < \ {
 ) / > ~ $ > .
  . . . . . .
   . . . . .
    . . . .

Це закінчується помилкою, але повідомлення про помилку переходить до STDERR.

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

Судячи з кількості дзеркал, можливо, навряд чи можна помістити його в бічну довжину 3, але поки що мені не пощастило.

Пояснення

Ось звичайна схема, сформована за допомогою шестигранних кольорів Timwi :

Програма використовує лише три ребра пам'яті, позначені тут A , B і C (діаграма надана Езотерицидом Тімві ):

Виконання починається на синьому шляху. Це /просто дзеркала, які перенаправляють покажчик інструкцій (IP), фактичний код:

,   Read character from STDIN into memory edge A.
)   Increment.
{   Move to memory edge B.
,   Read character from STDIN into memory edge B.
)   Increment.
'   Move to memory edge C.
%   Compute A mod B in memory edge C.

,Встановить край , щоб -1замість коду символу , якщо ми потрапили EOF. Оскільки ми збільшуємо обидва входи, це не змінюється, рівні вони чи ні, але перетворюється на EOF 0.

Ми використовуємо модуль для перевірки рівності, тому що це 1або 49(позитивний) для неоднакових символів і 0для рівних символів. Він також слугує кінцем програми, тому що, коли у нас є 0EOF, спроба поділу на нуль призведе до помилки.

Тепер <відмінні нулі від позитивних результатів. Перший простий: якщо символи рівні, IP-адреса бере червоний шлях. _це дзеркало, \це також дзеркало, але воно ігнорується, і >відхиляє IP-адресу таким чином, щоб він обернувся по краях і знову починався зверху. Однак на цій ітерації ролі A , B і C змінюються циклічно ( C зараз бере роль A і так далі).

Якщо символи різні, замість цього використовується зелений шлях. Це трохи мідніше. Він спочатку переходить через неопераційний режим $, потім завертається до /лівого краю, потім переходить другий останній ряд праворуч наліво і, нарешті, знову вводить цікаву частину вихідного коду в {. Існує по суті лінійний біт коду, який я поясню за секунду, перш ніж $змусити IP перейти через, >щоб знову об'єднати два контури.

Ось цей лінійний фрагмент коду:

{    Move to memory edge A.
(    Decrement to recover the actual character we read.
;    Print the character back to STDOUT.
'    Move to memory edge B.
~    Multiply the value there by -1, making it negative. This is
     necessary to ensure that the path correctly wraps back to the top.

Зауважимо, що в цьому випадку ролі ребер для наступної ітерації також змінюються циклічно, але з B, що приймає роль A тощо.

Haskell, 71 44 29 байт

p(a:b:r)=[a|a/=b]++p r
p _=[]

Екстремальний гольф від німі .

> <> , 11 байт

i:i:0(?;-?o

> <> досить добре підходить для читання-в-чарі, як це зараз :) Спробуйте в Інтернеті!

i:            Read char and duplicate
i             Read char
:0(?;         Halt if last char was EOF
-             Subtract
?o            Output first char if the subtraction was non-zero (i.e. not equal)

Все це відбувається в циклі, оскільки вказівник інструкції обертається, як тільки він доходить до кінця рядка.

Пітон, 42 байти

f=lambda L:L[1:]and L[:L[0]^L[1]]+f(L[2:])

Весело з рекурсією та побітним хором. Візьме список вхідних та 0-го списку як вхідні.

JavaScript (ES6), 33 байти

s=>s.filter((c,i)=>++i%2&c!=s[i])

Як це працює

s=>s                // Take the input array.
.filter((c,i)=>   ) // Filter to only the chars that are both:
++i%2&              //  on an even index, and
c!=s[i]             //  not equal to the one after them.

Прелюдія , 12 байт

11(-(#!)?^?)

Це передбачає перекладача, який читає та друкує символи. Ви можете спробувати його в Інтернеті. Але цей інтерпретатор друкує цілі числа, тому для кожного 0ви отримаєте, 48а для кожного 1ви отримаєте 49замість цього (і рядковий рядок).

Пояснення

Дуже рідко можна написати нетривіальну програму на одному рядку в Prelude (тому що Prelude потребує більше, ніж один рядок, щоб завершити Тьюрінга).

11      Push two 1s. We need something non-zero on the stack to enter the loop, and by
        pushing the same value twice, we make sure that the loop doesn't print anything
        on the first iteration.
(       Main loop...
  -       Subtract the last two values. This will be zero for equal values, and non-zero
          otherwise...
  (       This "loop" is simply used as a conditional: if the last two values were
          were equal, skip the code inside...
    #       Discard the conditional.
    !       Print the value below.
  )       The loop is exited because the value below is always zero.
  ?       Read the first character of the next pair from STDIN.
  ^       Duplicate it, so the lower copy can be printed.
  ?       Read the second character of the pair. This returns 0 at EOF, which
          terminates the loop.
)

Perl, 27 21 байт

say grep$_-chop,/../g

Байт додано для -n прапора.

                /../g  match groups of two chars
    grep       ,       select/filter on...
           chop        remove the last character, mutating the string
        $_-            is it different than the remaining char?
                         (subtract it, empty string is falsy)
say                    output if so

Тест:

llama@llama:~$ perl -nE 'say grep$_-chop,/../g'
1110
1
11000110
01
1100011
0
00

1



1101001
0
1011101010
1111

Дякуємо @TonHospel за 6 байт!

Befunge 93 , 16 байт

~:~:0`!#@_->#,_$

Одномісний вкладиш для компактності. Тестовано за допомогою цього онлайн-перекладача .

~:                     Read input char a and dup
  ~                    Read input char b (-1 on EOF)
   :0`!                Push 1 if b <= 0, 0 otherwise
       #@_             Halt if b <= 0 (i.e. EOF)
          -            Subtract to check whether a != b
           >#,_$       Output a if so

Остання частина використовує той факт, що вискакування з порожнього стека Befunge-93 дає 0 .

Якщо a != b, ми виконуємо

>                      Move rightward
#                      Bridge: skip next
_                      Horizontal if - go right if 0, else left. But a != b, so we go left
,                      Output a
#                      Bridge: skip next
-                      Subtract (0 - 0 = 0)
_                      If: go right since 0 is popped
>#                     Go right and skip next
_                      If: go right since 0 is popped
$                      Pop top of stack, stack is now empty

В іншому випадку, якщо a == bми виконуємо:

>                      Move rightward
#                      Bridge: skip next
_                      If: go right since a == b (i.e. a-b is 0)
$                      Pop top of stack and discard, keeping stack empty

Pyth, 10 9 байт

jkPM{Mcz2

Алгоритм безсоромно викрадений з відповіді Дженніса Желе .

       z    input
      c 2   chunks of 2
    {M      dedup each chunk
  PM        all-but-last element of each chunk
jk          join on empty string; can't use `s' because that gives `0' for []

Python 2, 48 байт

lambda n:[s for s,t in zip(*[iter(n)]*2)if s!=t]

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

Дякую Деннісу та ваулаті за вказівку речей, які я пропустив

Математика, 41 39 байт

Select[#~Partition~2,Tr@#==1&][[1]]&

Менш складна і коротша, ніж інша відповідь. Поле - символ транспозиції.

JavaScript (ES6), 33 байти

s=>s.replace(/(.)\1|(.)?./g,"$2")

Нудний порт відповіді Retina.

sed, 34 33 байт

s/../& /g;s/00\|11//g;s/.\b\| //g

Тест:

llama@llama:~$ sed 's/../& /g;s/00\|11//g;s/.\b\| //g'             
1110
1
11000110
01
1100011
0
00

1



1101001
0
1011101010
1111

Лабіринт , 31 байт

Не такий короткий і акуратний, як рішення Sp3000, але я подумав, що все-таки опублікую це як інший підхід:

"" @
,, :{"
)  { $;
*"})";.
 ""

Пояснення

Перша петля - просто

""
,,

який читає по два символи одночасно (знаки не є "). Після EOF ,повернеться -1, але перевіряйте лише EOF на кожен другий символ. Це означає, що в будь-якому випадку верхня стопка буде тоді-1 а значення нижче - або-1 або якийсь код символів, про який нам не байдуже, тому що це неспарене кидання монети.

Потім )*перетворюємо значення -1і значення нижче в єдине, 0яке нам потрібно а) позбутися цих двох значень і б) правильно ввести наступний цикл. Наступний цикл просто

"}
""

Який зміщує всі значення на допоміжний стек. Це необхідно, тому що ми хочемо почати обробляти пари, які ми читаємо спочатку. Тепер заключний цикл:

:{"
{ $;
)";.

У )кількох збільшень деякі фіктивне значення , щоб переконатися , що це позитивно , а до півночі покажчик інструкції витки. {тягне за собою першу цифру наступної пари і :дублює її. Тепер, коли ми закінчимо обробку, це буде 0з нижньої частини допоміжного стека. Інакше це 48або 49. У разі нуля виходимо з циклу і закінчуємо далі@ , інакше IP поверне на схід.

{тягне за іншу цифру поточної пари. $приймає ХОР між ними. Якщо це 0, тобто два рівні, IP просто продовжує рухатися на південь, ;відкидає нуль, і IP перетворюється на захід до наступної ітерації. Якщо XOR було 1, тобто вони були різними, IP повертає на захід, відкидає 1з ;і друкує першу цифру з ..

MATL , 11 9 8 байт

`-?6MD]T

Введення та вихід - це числа, розділені новими рядками. Закінчується помилкою (дозволено за замовчуванням), коли всі входи були витрачені.

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

`         % do...while loop
  -       %   take two inputs implicitly. Compute difference
  ?       %   if nonzero
    6M    %     push first of the two most recent inputs again
    D     %     display (and remove from stack)
  ]       %   end if
  T       %   true. Used as loop condition, so the loop is infinite
          % end loop implicitly

Старий підхід, 11 байт

2YCd9L)Xz0<

Введення - це рядок. Вихід - це числа, розділені новими рядками.

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

2YC      % implicitly take input as a string. Generate 2D array of length-2
         % overlapping blocks as columns, padding with a zero if needed.
d        % difference of the two values in each column of that array
9L       % predefined literal [1 2 0]. This corresponds to "1:2:end" indexing
)        % keep only values at indices 1, 3, 5, ... This reduces the set of blocks
         % to non-overlapping, and discards the last (padded) block if the input had
         % odd length
Xz       % keep only nonzero entries, corresponding to blocks that had different values
0<       % 1 if negative, 0 if possitive. Implicitly display

Рубін, 46 байт

Це розділяє l[0], l[1]і l[2..{end}]як a, bі c. Тоді він створює рядок з тим, aякщо є a!=bчи ''інакше, і f[c]якщо c[0]існує, чи ''інакше.

f=->l{a,b,*c=l;"#{a!=b ?a:''}#{c[0]?f[c]:''}"}

Безголівки:

def f(l)
  a = l[0]
  b = l[1]
  c = l[2..l.length]
  s = ''
  if a!=b
    s += a.to_s
  end
  if c[0]       # equivalent to !c.empty?
    s += f[c]   # no .to_s because the output will be a string
  end
  puts s
end

мозковий ебать, 33 байти

,>,[<[->->+<<]>[[-]>.<]>[-]<<,>,]

У порівнянні з Java, це дуже компактно, однак, я боюсь відповідального за мозку. І сміливо повідомляйте, чи є помилка. Якщо припустимо, що EOF дорівнює 0, введення не містить недійсного введення, комірка спочатку дорівнює нулю, а діапазон значень комірок - кінцевий і циклічний. Іншого припущення немає.

Пояснення:

Карта комірок пам'яті

+---------+---------+-----------------+
|1st input|2nd input|copy of 1st input|
+---------+---------+-----------------+

Інструкція

,>,                               read two instruction at once | first to first cell |
                                  second to second cell
   [                              Until the input is EOF
    <                             look at first cell
     [->->+<<]                    move the first cell to additional cells while
                                  subtracting the second cell with this at same
                                  time
              >[                  if the second cell is nonzero (it means that first cell and
                                  the second cell is the same)
                [-]>.<            Print the copied first input
                      ]
                       >[-]       clear the first input to prevent it polluting next input
                           <<,>,  continue with next two input
                                ]

Математика, 41 байт

Cases[#~Partition~2,a_/;Tr@a==1:>a[[1]]]&

Анонімна функція, яка вводить і виводить списки нулів і одиниць.

Pyth, 10 байт

hMf!qFTcz2

Тестовий набір

C, 66 байт

main(char*p,char**x){for(p=x[1];*p&p[1];p+=2)write(1,p,*p^p[1]);}

Припускаючи sizeof(int) == sizeof(char *)

«розумне» рішення - 84 81 байт

main(int c,short**x){while(!((c=*x[1]++-12336)&~511))c>>8^c&1&&putchar(48|c&1);}

Працює над припущенням малоінтенсивної машини short 2 байти. Введення передається як аргумент. Програма повторює пар пар символів та друкує 0 для 0x3130 та 1 для 0x3031. На зворотному порядку байт результату буде зворотним (замініть 48|c&1з , 49^c&1щоб виправити це).

C, 57 байт

f(char*p,char*r){for(;*p*p[1];)*r=*p++,r+=*r!=*p++;*r=0;}

Ми попередньо копіюємо символ із введення pв результатr , але лише просуваємо rвказівник, якщо він відрізняється від наступного символу. Якщо ні, то ми перезапишемо її на наступній незрівнянній парі або з NULв кінці.

Тестова програма:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char **argv) {
    while (*++argv) {
        char *result = malloc(1+strlen(*argv));
        f(*argv, result);
        printf("%s => %s\n", *argv, result);
        free(result);
    }
    return EXIT_SUCCESS;
}

Тестовий вихід:

$ ./74864 1110 11000110 1100011 00 1 "" 1101001 1011101010
1110 => 1
11000110 => 01
1100011 => 0
00 => 
1 => 
 => 
1101001 => 0
1011101010 => 1111

Befunge-93 , 40 байт

v  ,-1<
      | -<
>~1+:~1+:|
^     <  @

Ви можете спробувати тут . Вставте код у пробіл під кнопкою "показати", натисніть "показати", визначте введення, натисніть "запустити". Ми використовуємо кнопку «крок», щоб побачити, як працює програма.

DOS / Windows Batch, 201 162 байт

@echo off
set/pi=
:a
for /f "tokens=2" %%a in ("%i%") do goto l
exit/b
:l
for /f "tokens=1,2" %%a in ("%i:~0,4%") do if %%a neq %%b echo %%a
set "i=%i:~4%"
goto a

Вхід - це, наприклад, рядок, відокремлений пробілом 1 0 0 1 1. Почніть з cmd, інакше екран вийде негайно

бджолиний віск ,45 35 байт

Я міг би розіграти його на 10 байт - не надто погано.

pgy~1z;L?gAF1<<?V_
>&?@yg&?~@ KQd{b

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

Приклади:

julia> beeswax("FairCoin.bswx")
s1110
1
Program finished!

julia> beeswax("FairCoin.bswx")
s11000110
01
Program finished!

julia> beeswax("FairCoin.bswx")
s1100011
0
Program finished!

julia> beeswax("FairCoin.bswx")
s00

Program finished!

julia> beeswax("FairCoin.bswx")
s10101001010111111100000010011001110100010110101110100001011
1110001010000111100
Program finished!

Моє сховище бджолиного воску GitHub.

Мої приклади бджолиного воску на коді Rosetta.