당신은 생산 동전이 0또는 1. 그러나 동전이 편향되어 있다고 의심됩니다. 즉, 0(또는 1) 의 확률이 반드시 1/2 일 필요는 없습니다.

잘 알려진 에 바이어스 동전을 "변화"에 대한 절차 공정한 동전 폰 노이만에 의해 제안 된 (즉 똑같이 가능성이 결과를 얻기 위해)로 다음이다. 블록의 두 값이 다를 때까지 두 개의 코인 토스의 블록을 겹치지 않습니다 (겹치지 않음). 해당 블록의 첫 번째 값을 출력합니다 (두 번째 값도 마찬가지이지만이 문제의 목적을 위해 첫 번째 값을 선택 함). 직관적으로, 1보다 더 가능성이있을 수 0있지만, 01과 10똑같이 가능성이있을 것입니다.

예를 들어, 입력 1110...은 첫 번째 블록을 버리고 1두 번째 블록에서 ... 을 생성합니다 .

단일 결과를 생성하기 위해 여러 개의 동전 던지기가 소비되기 때문에이 절차는 비용 이 많이 듭니다 .

도전

원래 동전의 토스를 나타내는 0과 1의 유한 순서를 취하고 모든 입력이 소비 될 때까지 위의 절차에 따라 최대 결과 수를 생성하십시오 .

입력 값의 수가 홀수 인 경우 마지막 블록이 불완전 할 수 있습니다. 예를 들어, 입력 시퀀스 11111는 결과를 생성하지 않습니다 (처음 두 블록은 동일한 값을 가지며 세 번째 블록은 불완전합니다).

규칙

입력은 음수가 아닌 값을 가질 수 있으며 반드시 양수이거나 짝수는 아닙니다.

입력 형식은 다음과 같습니다.

• 0과 1의 배열;
• 선택적 구분 기호가있는 0과 1의 문자열

출력 형식은 다음과 같습니다.

• 구분 기호가 있거나없는 0과 1의 문자열;
• 0과 1의 배열;
• 개행으로 구분 된 단일 0 또는 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|(.)?.두 번째 그룹이 캡처 한 항목으로 대체하는 단일 정규식 대체를 정의합니다 . 이것은 세 가지 경우를 하나로 결합합니다.

(.)\1 --> <empty>

두 개의 반복 숫자가 같으면 그룹 2를 사용하지 않기 때문에 문자열에서 제거합니다.

(.).  --> $2

그렇지 않으면 두 문자를 일치시킬 수 있으면 두 번째 문자를 모두 첫 번째 문자로 바꾸어 두 번째 문자를 제거하십시오. 그렇지 않은 경우 ?그룹을 생략합니다.

.     --> <empty>

짝을 이루지 않는 후행 문자가있는 경우에만 발생하며이 문자도 제거됩니다.

미로 , 21 12 바이트

"(. :
""*$,@

드물지 않은 소형 미로 프로그램의 드문 예입니다. |이전 버전의 완전히 불필요하고는 대량 프로그램의 크기를 감소 제거하는 단계. 실은 랩이 레티 나를 때리고 있어요!

온라인으로 사용해보십시오!

왼쪽 하단 "도 공백 일 수 있지만 공간이 있으면 설명이 크게 단순화됩니다.

설명

이것은 조금 까다 롭기 때문에 이미지가 동반됩니다. 그러나 먼저, 빠른 입문서 :

• Labyrinth는 스택 기반 2D 언어입니다. 메모리는 메인 스택과 보조 스택으로 구성됩니다.
• Labyrinth의 스택은 바닥이없고 0으로 채워 지므로 빈 스택에서 작업을 수행하는 것은 오류가 아닙니다.
• 명령 포인터가 이동할 경로가 두 개 이상인 각 접점에서 메인 스택의 상단을 확인하여 다음에 갈 곳을 찾습니다. 음수는 좌회전, 0은 직진, 양수는 우회전입니다. 회전이 실패하면 포인터가 다른 방향으로 회전하려고합니다.

설정

프로그램은 왼쪽 상단에서 시작합니다 ". 그런 다음 수행합니다.

(        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에있다. 이것은 0이 아니기 때문에 :스택의 상단을 복제하는 로 변환됩니다 .

는 :우리가 돌아서 실행할 수 있도록, 막 다른 끝에 ,한 번 더. 마지막 입력 EOF라면 이제, 우리는 좌회전과 종료 @, 다른 우리처럼 보이는 스택, 우회전 [a a b](여기서 a, b두 개의 문자이다).

동전 던지기 해석

종료하지 않았다면 다음 단계는 $(비트 xor)를 다시 실행하는 것 입니다. 입력 문자가 같으면 0이되고, 그렇지 않으면 1이됩니다. 그런 다음 a이 결과 를 곱하여 0 또는을 제공합니다 a. (가) 때문에 *접합시이며,이 상부 더미 값은 다음에 발생하는 결정.

0의 경우 감소 "를 수행하기 전에 똑바로 가서 세 번의 no-ops를 실행하십시오 (. 설정과 마찬가지로 이것은 우리를 돌리고 실행 "*$시켜 더 많은 문자를 읽을 준비를합니다.

그렇지 않으면 양수 (48 또는 49) a이므로 접합점에서 우회전 a합니다. .문자를 출력하고 스택을 비워두고 스택 (의 상단을 감소시켜 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).
}%

프로그램이 끝날 때 목록이 자동 인쇄되면 빈 문자열은 생략됩니다.

펄, 19 18 17 바이트

@Martin Büttner Retina 솔루션은 2 바이트 이득을 얻었습니다.

에 +1 포함 -p

STDIN의 입력으로 실행 perl -p fair.pl <<< 11000110

fair.pl:

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

사양의 (간접) 번역이기 때문에 여기에 설명하지 않아도됩니다.

• (.)\1 처음 두 자리가 같으면 떨어 뜨립니다.
• .\K. 그렇지 않으면 처음 두 자리가 다릅니다. \K첫 번째 것을 유지 ( )
• .?\K.첫 번째 .는 선택 사항입니다. 이것은 문자열의 끝에 단일 일치를 허용하고 유지 된 부분이 비어 있기 때문에 버려집니다.

Mathematica, 36 38 바이트

2 요소 목록이 {0,1} 또는 {1,0}인지 판별하기위한 @ LegionMammal978의 함수를 훔친 후 -2

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

인수는 정수 목록 일 것으로 예상됩니다.

헥사 고니 , 23 21 바이트

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

펼쳐진 :

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

오류와 함께 종료되지만 오류 메시지는 STDERR로 이동합니다.

온라인으로 사용해보십시오!

거울의 수로 판단하면 측면 길이 3에 맞추는 것이 가능할 수도 있지만 지금까지 운이 없었습니다.

설명

Timwi의 HexagonyColorer로 생성 된 일반적인 다이어그램은 다음과 같습니다 .

이 프로그램은 여기에 A , B 및 C 라는 레이블이 지정된 세 개의 메모리 에지 만 사용합니다 (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를 가질 때 0으로 나누려고 시도하면 오류가 발생 하기 때문에 프로그램의 끝으로도 사용됩니다 .

이제는 <0을 긍정적 인 결과와 구별합니다. 가장 간단한 방법 : 문자가 같으면 IP가 빨간색 경로를 사용합니다. _는 \미러이지만 미러이기도하지만 무시 >되며 IP를 변형하여 가장자리를 감싸고 맨 위에서 다시 시작합니다. 그러나이 반복에서 A , B 및 C 의 역할은 주기적으로 교체됩니다 ( C는 이제 A 의 역할을 수행함 ).

문자가 다르면 녹색 경로가 대신 사용됩니다. 이것은 조금 더 지저분합니다. 먼저와 함께 no-op 위로 점프 $한 다음 /왼쪽 가장자리 를 감싸고 오른쪽에서 왼쪽으로 두 번째에서 마지막 행을 가로 질러 마지막으로에서 소스 코드의 흥미로운 부분을 다시 입력합니다 {. 본질적으로 선형적인 코드 비트가 있는데, 두 번째 경로를 다시 병합하기 위해 $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 등 의 역할을 합니다.

하스켈, 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:])

재귀와 비트 xor로 재미 있습니다. 1과 0의 목록을 입력으로 취합니다.

자바 스크립트 (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.

Prelude , 12 바이트

11(-(#!)?^?)

이것은 문자를 읽고 인쇄하는 인터프리터를 가정합니다. 온라인으로 사용해 볼 수 있습니다. 그러나 해당 인터프리터는 정수를 인쇄하므로 0얻을 수있는 48각각에 대해 대신 줄 바꿈을 1얻습니다 49.

설명

Prelude에서 한 줄에 중요하지 않은 프로그램을 작성할 수있는 경우는 매우 드 rare니다 (Prelude는 Turing-complete가 되려면 두 줄 이상이 필요하기 때문입니다).

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.
)

펄, 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 답변 에서 부끄럽게 도난당한 알고리즘 .

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

파이썬 2, 48 바이트

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

온라인으로 사용해보십시오

내가 놓친 것들을 지적 해 준 Dennis와 Vaultah에게 감사합니다.

Mathematica, 41 39 바이트

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

다른 답변보다 덜 복잡하고 짧습니다. 상자는 조옮김 문자입니다.

자바 스크립트 (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의 솔루션만큼 짧고 깔끔하지는 않지만 어쨌든 이것을 다른 접근 방식으로 게시 할 것이라고 생각했습니다.

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

설명

첫 번째 루프는 단순히

""
,,

한 번에 두 문자로 읽습니다 ( "op-ops 없음). EOF 후에 ,는을 반환 -1하지만 매 초마다 EOF 만 확인합니다. 즉, 스택의 맨 위가되고 -1아래 값은 -1우리가 신경 쓰지 않는 문자 코드 또는 일부입니다. 페어링되지 않은 동전 던지기이기 때문입니다.

그런 다음 )*을 전환 -1하고 단일로 아래의 값 0) 우리가이 필요한 올바르게 다음 루프를 입력하는 두 b 값)를 제거 할 수 있습니다. 그 다음 루프는 단순히

"}
""

모든 값을 보조 스택으로 이동시킵니다. 우리가 먼저 읽은 쌍을 처리하기 시작하기 때문에 이것이 필요합니다. 이제 마지막 루프 :

:{"
{ $;
)";.

)단지 단위로 몇 가지 더미 값은 긍정적이고 명령 포인터의 회전 북쪽 있음을 확인합니다. {다음 쌍의 첫 번째 숫자를 가져 와서 :복제합니다. 이제 처리가 완료 0되면 보조 스택의 맨 아래부터 시작됩니다. 그렇지 않으면 48또는 49입니다. 0의 경우 루프를 종료하고을 종료합니다 @. 그렇지 않으면 IP가 동쪽으로 바뀝니다.

{현재 쌍의 다른 숫자를 가져옵니다. $그들 사이에 XOR을 가져옵니다. 그것이 0이면, 즉 둘이 동일하면 IP는 계속 남쪽으로 이동 ;하고 0을 버리고 IP는 서쪽을 다음 반복으로 바꿉니다. XOR 1이 다른 경우 , 즉 서로 다르면 IP가 서쪽으로 바뀌고 1with를 버리고 ;첫 번째 숫자를로 인쇄합니다 ..

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이라고 가정하면 입력에 유효하지 않은 입력이없고 셀이 처음에는 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]]]&

0과 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에서 결과 로 문자를 잠정적으로 복사 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

나는 동전 던지기 접근법의 전체 문자열을 읽었으므로 프로그램이 꽤 커졌습니다. 하나의 정수를 하나씩 읽는 것만으로도 프로그램이 더 작아 지지만 (약 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 코드에 대한 나의 밀랍 예제.