0またはを生成するコインがあります1。しかし、コインは偏っている可能性があると思われます。つまり、0（または1）の確率は必ずしも1/2ではありません。

フォン・ノイマンによって提案された、偏ったコインを公正なコインに「変換」する（すなわち、同等の結果を得る）ためのよく知られた手順は次のとおりです。ブロックの2つの値が異なるまで、2つのコイントスの（重複しない）ブロックを生成します。そのブロックの最初の値を出力します（2番目の値でも同様ですが、この課題のために最初のものを選択します）。直感的には、よりも高い可能性がありますが、同様に可能性があります。100110

たとえば、入力1110...は最初のブロックを破棄1し、2番目のブロックからa を生成します...

単一の結果を生成するために複数のコイントスが消費されるため、この手順は高価です。

チャレンジ

元のコインのトスを表すゼロと1の有限シーケンスを取り、すべての入力が消費されるまで、上記の手順に従って最大数の結果を生成します。

入力値の数が奇数の場合、最後のブロックは不完全な場合があります。たとえば、入力シーケンス11111は結果を生成しません（最初の2つのブロックの値は等しく、3番目のブロックは不完全です）。

ルール

入力は、負または負の数の値を持つことができ、必ずしも正または偶数である必要はありません。

入力形式は次のとおりです。

• ゼロと1の配列。
• オプションの区切り文字を含むゼロと1の文字列。

出力形式は次のとおりです。

• セパレーターの有無にかかわらず、ゼロと1のストリング。
• ゼロと1の配列。
• 改行で区切られた単一のゼロまたは1を含む文字列。
• あなたの言語に合った同様の合理的なフォーマット。

コードゴルフ。最少バイトが勝ちます。

テストケース

ここでは、入力と出力は文字列であると想定されています。

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|(.)?.2番目のグループがキャプチャしたものに置き換える単一の正規表現置換を定義しています。これにより、3つの異なるケースが1つにまとめられます。

(.)\1 --> <empty>

繰り返される2つの数字が等しい場合、それらを文字列から削除します（グループ2は使用されていないため）。

(.).  --> $2

それ以外の場合、2つの文字に一致する場合は、2番目の文字を両方とも最初の文字に置き換えて削除します。そうでない場合?、グループは省略されます。

.     --> <empty>

これは、ペアになっていない末尾の文字がある場合にのみ発生し、末尾の文字も削除されます。

ラビリンス、21 12バイト

"(. :
""*$,@

ノーオペレーションも持たないコンパクトなラビリンスプログラムのまれな例。|以前のバージョンでは完全に不必要であり、それは大規模なプログラムのサイズを減少させ除去します。実際、LabはRetinaを打ち負かしています！

オンラインでお試しください！

左下"もスペースにすることができますが、そこにあると説明が大幅に簡略化されます。

説明

これは少し難しいので、画像を添付します。しかし、最初に、簡単な入門書：

• Labyrinthは、スタックベースの2D言語です。メモリは、メインスタックと補助スタックで構成されます。
• Labyrinthのスタックは底がなく、ゼロで埋められているため、空のスタックで操作を実行してもエラーにはなりません。
• 各ジャンクションで、命令ポインタが移動するためのパスが2つ以上ある場合、メインスタックの上部をチェックして、次に移動する場所を見つけます。負は左に曲がり、ゼロはまっすぐ進み、正は右に曲がります。ターンが失敗した場合、ポインターは他の方向を向こうとします。

セットアップ

プログラムは左上から始まりますが"、これは何もしません。次に実行します：

(        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、b2つの文字です）。

コイントスの解釈

終了しなかった場合、次の動きは$（ビットごとのxor）を再度実行することです。入力文字が同じ場合は0、そうでない場合は1になります。次にa、この結果を乗算し、0またはを与えますa。以来、*接合部であり、このトップスタックの値が次に何が起こるかを判断します。

0の場合、デクリメントを"実行する前に、まっすぐ進み、3つのノーオペレーションを実行し(ます。セットアップと同様に、これにより、ターンして実行し"*$、さらに文字を読み込む準備ができます。

それ以外の場合、このa場合、a正（48または49）なのでジャンクションで右折します。.文字を出力し、スタックを空のままにし、スタック(の最上部をデクリメントし、0から-1に変更します。繰り返しになりますが、これにより"*$、セットアップのように左に曲がり、さらに入力を読む準備ができています。

CJam、10 8バイト

l2/{)-}%

ここでテストしてください。

説明

これは非常に簡単なソリューションです。各ペアで、最後のキャラクターのすべてのインスタンスを削除します。繰り返された数字とペアになっていない末尾の数字は削除され、不等桁のペアの2番目の数字も削除されます。

"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バイト

@MartinBüttnerRetinaソリューションは2バイトのゲインを生み出しました

+1を含む -p

STDINの入力で実行します。例えば perl -p fair.pl <<< 11000110

fair.pl：

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

これは仕様の（間接的な）翻訳であるため、ここではあまり説明しません。

• (.)\1 最初の2桁が同じ場合は、ドロップします
• .\K. それ以外の場合、最初の2桁は異なります。\K最初のものを保持（）
• .?\K.最初のもの.がオプションであることを除いて。これにより、保持された部分が空であるため、文字列の最後で単一の一致が破棄されます。

Mathematica、36 38バイト

-2 2要素リストが{0,1}または{1,0}であるかどうかを判断する@ LegionMammal978の関数を盗んだ後

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

引数は整数のリストであることが期待されています。

六角形、23 21バイト

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

展開：

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

これはエラーで終了しますが、エラーメッセージはSTDERRに送られます。

オンラインでお試しください！

ミラーの数から判断すると、サイドレングス3に収めることはほぼ可能かもしれませんが、これまでのところ運がありませんでした。

説明

以下は、TimwiのHexagonyColorerで生成された通常のダイアグラムです。

プログラムは、ここでA、B、およびCとラベル付けされた 3つのメモリエッジのみを使用します（TimwiのEsotericIDEの好意による図）：

青いパスで実行が開始されます。これら/は、命令ポインタ（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ます。また、0from EOFがある場合、ゼロによる除算の試行によりエラーが発生するため、プログラムの終了としても機能します。

これで、<ゼロと肯定的な結果が区別されます。最初の単純なもの：文字が等しい場合、IPは赤いパスを取ります。_はミラーであり、ミラーで\もありますが、無視され、>エッジの周りを包み込み、再び上から始まるようにIP を偏向します。ただし、この反復では、A、B、およびCの役割は周期的に交換されます（CはAの役割を担うようになりました）。

文字が異なる場合、代わりに緑のパスが使用されます。これは少し厄介です。最初にnoでジャンプし$、次に/左端に回り込んでから、最後から2番目の行を右から左に横断し、最後にソースコードの興味深い部分に再び入り{ます。$IPがジャンプ>して2つのパスを再びマージする前に、基本的に線形のコードがあります。

コードの線形部分は次のとおりです。

{    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

> <>は、次のような文字を1つずつ読むという課題に非常に適しています:) オンラインで試してみてください！

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)

命令ポインタは行の終わりに達すると折り返されるため、これはすべてループで発生します。

Python、42バイト

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

再帰とビット単位のXORをお楽しみください。1と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で単一行に重要なプログラムを書くことができるのは非常にまれです（Turingを完成させるには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

6バイトの@TonHospelに感謝します！

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

DennisのJelly answerから恥知らずに盗まれたアルゴリズム。

       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]

オンラインで試す

私が見逃したものを指摘してくれたデニスとヴォーターに感謝

Mathematica、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のソリューションほど短く簡潔ではありませんが、とにかく別のアプローチとしてこれを投稿すると思いました。

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

説明

最初のループは単純に

""
,,

一度に2文字を読み取ります（"no-ops）。EOFの後、,を返しますが-1、2文字ごとにEOFのみをチェックします。つまり、いずれの場合もスタックの最上部に-1なり、以下の値は-1、ペアになっていないコイントスなので、気にする必要のない文字コードのいずれかまたはいくつかです。

次に)*、-1以下の0値を、a）これらの2つの値を取り除くために必要な単一の値に変換し、b）次のループに入るために正しく入力します。次のループは単純に

"}
""

すべての値を補助スタックにシフトします。これは、最初に読み取ったペアの処理を開始するために必要です。最後のループ：

:{"
{ $;
)";.

)ただ刻み、それは北ポジティブだと命令ポインタターンすることを確実にするために、いくつかのダミーの値。{次のペアの最初の数字を引き出して:複製します。処理が終了すると、これは0補助スタックの最下部からのものになります。それ以外の場合は、48または49です。ゼロの場合、ループを終了して@で終了します。それ以外の場合、IPは東になります。

{現在のペアのもう一方の数字をプルします。$それらの間でXORを取ります。それが0の場合、つまり2つが等しい場合、IPは南に移動し続け;、ゼロを破棄し、IPは次の反復に西になります。XORがであった場合1、つまり、それらが異なっていた場合、IPは西を向き、1with ;を破棄し、最初の数字をwith で出力し.ます。

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。次に、aif a!=bまたは''else を含む文字列と、f[c]if 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

brainfuck、33バイト

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

Javaと比較すると、これは非常にコンパクトですが、brainfuck-golfer answererは怖いです。また、バグがある場合はお気軽にご連絡ください。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
                                ]

Mathematica、41バイト

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

ゼロと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);}

short2バイトを想定して、リトルエンディアンのマシンで動作します。入力は引数として渡されます。プログラムは文字のペアを反復処理し、0x3130の場合は0、0x3031の場合は1を出力します。ビッグエンディアンで結果が（置き換え逆になります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からresult 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+:|
^     <  @

ここで試してみることができます。「show」ボタンの下のスペースにコードを貼り付け、「show」を押し、入力を定義し、「run」を押します。「ステップ」ボタンを使用して、プログラムの動作を確認します。

DOS / Windowsバッチ、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

私が取ったコイン投げのアプローチの読み込み完全な文字列のプログラムはかなり大規模になり、。単一の整数を1つずつ読み取るだけで、プログラムは小さくなります（約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 Codeでの蜜蝋の例。