Bạn có một đồng tiền sản xuất 0hoặc 1. Nhưng bạn nghi ngờ đồng xu có thể bị sai lệch , có nghĩa là xác suất 0(hoặc 1) không nhất thiết là 1/2.

Một thủ tục nổi tiếng để "biến đổi" một đồng xu thiên vị thành một đồng tiền công bằng (nghĩa là để có được kết quả có khả năng như nhau), như đề xuất của von Neumann, như sau. Sản xuất các khối (không chồng lấp) của hai lần tung đồng xu cho đến khi hai giá trị của một khối khác nhau; và xuất giá trị đầu tiên trong khối đó (giá trị thứ hai cũng sẽ làm được, nhưng với mục đích của thử thách này, chúng tôi chọn giá trị đầu tiên). Bằng trực giác, 1có thể có nhiều khả năng hơn 0, nhưng 01và 10sẽ đều có khả năng.

Ví dụ: đầu vào 1110...sẽ loại bỏ khối đầu tiên, sau đó tạo 1khối từ khối thứ hai, ...

Thủ tục này rất tốn kém , vì một số lần tung đồng xu được tiêu thụ để tạo ra một kết quả duy nhất.

Các thách thức

Thực hiện một chuỗi hữu hạn các số 0 và số 0, đại diện cho việc tung đồng xu ban đầu và tạo ra số lượng kết quả tối đa theo quy trình trên, cho đến khi tất cả đầu vào được tiêu thụ.

Khối cuối cùng có thể không đầy đủ, nếu số lượng giá trị đầu vào là số lẻ. Ví dụ, chuỗi đầu vào 11111sẽ không tạo ra kết quả (hai khối đầu tiên có giá trị bằng nhau và khối thứ ba không đầy đủ).

Quy tắc

Đầu vào có thể có bất kỳ số lượng giá trị không âm, không nhất thiết là dương hoặc chẵn.

Định dạng đầu vào có thể là:

• một mảng số không và số không;
• một chuỗi các số không và các số có dấu phân cách tùy chọn.

Định dạng đầu ra có thể là:

• một chuỗi số không và số không, có hoặc không có dấu phân cách;
• một mảng số không và số không;
• các chuỗi chứa một số 0 hoặc một, được phân tách bằng các dòng mới;
• bất kỳ định dạng tương tự, hợp lý phù hợp với ngôn ngữ của bạn.

Mã golf. Ít byte nhất sẽ thắng.

Các trường hợp thử nghiệm

Đầu vào và đầu ra ở đây được coi là chuỗi.

Input         -->  Output

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

Thạch, 6 byte

s2Q€Ṗ€

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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.

Võng mạc , 16 14 byte

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

Hãy thử trực tuyến!

Giải trình

Điều này khá đơn giản. Mã xác định một thay thế regex duy nhất thay thế tất cả các kết quả khớp (không chồng lấp) (.)\1|(.)?.bằng bất cứ thứ gì mà nhóm thứ hai thu được. Điều này kết hợp ba trường hợp khác nhau thành một:

(.)\1 --> <empty>

Nếu hai chữ số lặp lại bằng nhau, chúng tôi xóa chúng khỏi chuỗi (vì nhóm 2 không được sử dụng).

(.).  --> $2

Mặt khác, nếu chúng ta có thể ghép hai ký tự, loại bỏ ký tự thứ hai, bằng cách thay thế cả hai ký tự bằng ký tự đầu tiên. Nếu đó không phải là trường hợp ?sẽ bỏ qua nhóm:

.     --> <empty>

Điều này chỉ xảy ra nếu có một ký tự không ghép đôi, cũng được loại bỏ.

Mê cung , 21 12 byte

"(. :
""*$,@

Một ví dụ hiếm hoi về chương trình Labyrinth nhỏ gọn cũng không có không có hoạt động. Các |trong phiên bản trước đây là hoàn toàn không cần thiết và xoá nó ồ ạt giảm kích thước của chương trình. Thực tế, Lab đang đánh bại Retina!

Hãy thử trực tuyến!

Phía dưới bên trái "cũng có thể là một khoảng trắng, nhưng có nó ở đó đơn giản hóa rất nhiều lời giải thích.

Giải trình

Đây là một chút phức tạp hơn, vì vậy nó đi kèm với hình ảnh. Nhưng trước tiên, một mồi nhanh:

• Labyrinth là một ngôn ngữ 2D dựa trên ngăn xếp. Bộ nhớ bao gồm một ngăn xếp chính và một ngăn xếp phụ trợ.
• Các ngăn xếp của Labyrinth là không đáy và chứa đầy các số 0, do đó, thực hiện các thao tác trên một ngăn xếp trống không phải là một lỗi.
• Tại mỗi ngã ba, nơi có hai hoặc nhiều đường dẫn cho con trỏ lệnh đi tới, đỉnh của ngăn xếp chính được kiểm tra để tìm ra nơi tiếp theo. Tiêu cực là rẽ trái, không là thẳng về phía trước và tích cực là rẽ phải. Nếu một lượt không thành công, con trỏ cố gắng rẽ theo hướng khác.

Thiết lập

Chương trình bắt đầu ở phía trên bên trái ", đó là một no-op. Sau đó chúng tôi thực hiện:

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

Điều này để lại ngăn xếp với một số 0 duy nhất trên đó, cũng tốt như trống cho các mục đích của Labyrinth.

Đọc đầu vào và chấm dứt

,đọc một char từ đầu vào, trả về 48 hoặc 49 tương ứng 0hoặc 1-1 trên EOF. Vì đây là khác không, nên dù chúng ta biến thành cái nào :, nó sẽ nhân đôi đỉnh của ngăn xếp.

Các :là một ngõ cụt, vì vậy chúng tôi quay lại và thực hiện ,một lần nữa. Bây giờ nếu đầu vào cuối cùng là EOF, thì chúng ta rẽ trái và kết thúc @, nếu không chúng ta rẽ phải, với ngăn xếp trông giống như [a a b](trong đó a, blà hai ký tự).

Giải thích việc tung đồng xu

Nếu chúng tôi không chấm dứt, bước tiếp theo của chúng tôi là thực hiện lại $(bitwise xor). Điều này mang lại 0 nếu các ký tự đầu vào giống nhau, 1 khác. Sau đó, chúng tôi nhân avới kết quả này, cho 0 hoặc a. Vì *nằm ở một ngã ba, giá trị ngăn xếp trên cùng này xác định điều gì xảy ra tiếp theo.

Trong trường hợp 0, chúng ta đi thẳng và thực hiện ba "lệnh cấm, trước khi thực hiện (giảm dần. Giống như thiết lập, điều này làm cho chúng ta xoay và thực hiện "*$, khiến chúng ta sẵn sàng để đọc thêm ký tự.

Mặt khác, trong atrường hợp, chúng ta rẽ phải tại ngã ba vì alà dương (48 hoặc 49). .xuất char, để trống ngăn xếp và (giảm đỉnh của ngăn xếp, biến 0 thành -1. Một lần nữa, điều này làm cho chúng ta rẽ trái, thực hiện "*$như trong thiết lập, cũng khiến chúng ta sẵn sàng để đọc thêm đầu vào.

CJam, 10 8 byte

l2/{)-}%

Kiểm tra nó ở đây.

Giải trình

Đây là một giải pháp rất đơn giản: trong mỗi cặp, loại bỏ tất cả các trường hợp của ký tự cuối cùng. Các chữ số lặp lại và các chữ số không ghép đôi sẽ bị xóa, vì đây sẽ là chữ số thứ hai trong bất kỳ cặp chữ số không bằng nhau nào:

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

Điều này chỉ để lại các chữ số chúng tôi đang tìm kiếm. Đây là cách mã tính toán này:

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

Khi danh sách được in tự động vào cuối chương trình, các chuỗi trống sẽ bị bỏ qua.

Perl, 19 18 17 byte

@Martin Büttner Giải pháp Retina lấy cảm hứng tăng 2 byte

Bao gồm +1 cho -p

Chạy với đầu vào trên STDIN, vd perl -p fair.pl <<< 11000110

fair.pl:

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

Không có nhiều điều để giải thích ở đây vì đây là bản dịch (gián tiếp) của đặc tả:

• (.)\1 Nếu 2 chữ số đầu tiên giống nhau, hãy thả chúng
• .\K. Nếu không, hai chữ số đầu tiên là khác nhau. Giữ ( \K) cái đầu tiên
• .?\K.Ngoại trừ việc đầu tiên .là tùy chọn. Điều này cho phép một trận đấu duy nhất ở cuối chuỗi mà sau đó bị loại bỏ vì phần được giữ trống

Toán học, 36 38 byte

-2 sau khi đánh cắp chức năng của @ LegionMammal978 để xác định xem danh sách 2 phần tử là {0,1} hay {1,0}

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

Đối số dự kiến ​​sẽ là một danh sách các số nguyên.

Lục giác , 23 21 byte

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

Mở ra:

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

Điều này chấm dứt với một lỗi, nhưng thông báo lỗi đi đến STDERR.

Hãy thử trực tuyến!

Đánh giá theo số lượng gương có thể phù hợp với nó ở độ dài 3 cạnh nhưng tôi đã không gặp may mắn cho đến nay.

Giải trình

Đây là sơ đồ thông thường, được tạo bằng HexagonyColorer của Timwi's :

Chương trình chỉ sử dụng ba cạnh bộ nhớ, được gắn nhãn A , B và C tại đây (sơ đồ lịch sự của Timwi's EsotericIDE ):

Thực hiện bắt đầu trên con đường màu xanh. Đây /chỉ là các gương chuyển hướng con trỏ lệnh (IP), mã thực tế là:

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

Ý ,chí sẽ đặt cạnh -1thay vì mã ký tự nếu chúng ta nhấn EOF. Vì chúng tôi tăng cả hai yếu tố đầu vào không thay đổi dù chúng có bằng nhau hay không, nhưng nó biến EOF thành 0.

Chúng tôi sử dụng modulo để kiểm tra sự bằng nhau, bởi vì đó là 1hoặc 49(dương) cho các ký tự không bằng nhau và 0cho các ký tự bằng nhau. Nó cũng đóng vai trò là phần cuối của chương trình, bởi vì khi chúng ta có 0từ EOF, phép chia bằng 0 sẽ gây ra lỗi.

Bây giờ các <phân biệt số không với kết quả tích cực. Cách đơn giản trước: nếu các ký tự bằng nhau, IP sẽ nhận đường dẫn màu đỏ. _là một tấm gương, \cũng là một tấm gương nhưng bị bỏ qua và >làm chệch hướng IP sao cho nó quấn quanh các cạnh và bắt đầu lại từ đầu. Tuy nhiên, trong lần lặp này, vai trò của A , B và C được hoán đổi theo chu kỳ ( C bây giờ đóng vai trò của A và cứ thế).

Nếu các ký tự khác nhau, đường dẫn màu xanh lá cây được thực hiện thay thế. Cái này lộn xộn hơn một chút. Đầu tiên, nó nhảy qua một no-op với $, sau đó quấn quanh /cạnh bên trái, sau đó đi qua hàng thứ hai đến cuối cùng từ phải sang trái và cuối cùng nhập lại phần thú vị của mã nguồn tại {. Có một đoạn mã cơ bản tuyến tính, mà tôi sẽ giải thích trong một giây, trước khi $làm cho IP nhảy qua >để hợp nhất hai đường dẫn lại.

Đây là đoạn mã tuyến tính:

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

Lưu ý rằng trong trường hợp này, vai trò của các cạnh cho lần lặp tiếp theo cũng được hoán đổi theo chu kỳ, nhưng với B giữ vai trò của A , v.v.

Haskell, 71 44 29 byte

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

Chơi golf cực đỉnh bằng nimi .

> <> , 11 byte

i:i:0(?;-?o

> <> khá phù hợp với những thử thách đọc sách như thế này :) Hãy thử trực tuyến!

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)

Tất cả điều này xảy ra trong một vòng lặp vì con trỏ lệnh bao bọc xung quanh khi nó đến cuối dòng.

Python, 42 byte

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

Vui với đệ quy và bitor xor. Lấy danh sách 1s và 0 làm đầu vào.

JavaScript (ES6), 33 byte

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

Làm thế nào nó hoạt động

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.

Mở đầu , 12 byte

11(-(#!)?^?)

Điều này giả sử một thông dịch viên đọc và in các ký tự. Bạn có thể sắp xếp thử trực tuyến. Nhưng trình thông dịch đó in các số nguyên, vì vậy với mỗi 0bạn sẽ nhận được48 và thay vào đó, mỗi người 1bạn sẽ nhận được 49(và một nguồn cấp dữ liệu).

Giải trình

Rất hiếm khi bạn có thể viết một chương trình không tầm thường trên một dòng trong Prelude (vì Prelude cần nhiều hơn một dòng để hoàn thành Turing).

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 byte

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

Byte thêm cho -ncờ.

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

Kiểm tra:

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

1



1101001
0
1011101010
1111

Cảm ơn @TonHeach cho 6 byte!

Befunge 93 , 16 byte

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

Một lớp lót cho sự nhỏ gọn. Đã thử nghiệm bằng cách sử dụng thông dịch viên trực tuyến này .

~:                     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

Phần cuối cùng sử dụng thực tế là xuất hiện từ ngăn xếp Befunge-93 trống rỗng mang lại 0 .

Nếu a != b, chúng tôi thực hiện

>                      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

Mặt khác, nếu a == b, chúng tôi thực hiện:

>                      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

Bình thường, 10 9 byte

jkPM{Mcz2

Thuật toán bị đánh cắp một cách đáng xấu hổ từ câu trả lời Jelly của Dennis .

       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 byte

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

Dùng thử trực tuyến

Cảm ơn Dennis và vaultah vì đã chỉ ra những thứ mà tôi đã bỏ lỡ

Toán học, 41 39 byte

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

Ít phức tạp và ngắn hơn so với câu trả lời khác. Hộp là một nhân vật chuyển vị.

JavaScript (ES6), 33 byte

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

Cổng nhàm chán của câu trả lời Retina.

sed, 34 33 byte

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

Kiểm tra:

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

1



1101001
0
1011101010
1111

Mê cung , 31 byte

Không ngắn gọn và gọn gàng như giải pháp của Sp3000, nhưng tôi nghĩ dù sao tôi cũng sẽ đăng bài này như một cách tiếp cận khác:

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

Giải trình

Vòng lặp đầu tiên chỉ đơn giản là

""
,,

đọc hai ký tự cùng một lúc ( "không có op-op). Sau EOF, ,sẽ trở lại -1, nhưng chỉ kiểm tra EOF ở mỗi ký tự thứ hai. Điều đó có nghĩa là trong mọi trường hợp, đỉnh của ngăn xếp sẽ là -1và giá trị bên dưới là-1 hoặc một số mã ký tự mà chúng ta không quan tâm, bởi vì đó là một đồng xu không ghép đôi.

Sau đó )*biến -1giá trị và giá trị bên dưới thành một giá trị 0mà chúng ta cần a) để loại bỏ hai giá trị đó và b) để vào vòng lặp tiếp theo một cách chính xác. Vòng lặp tiếp theo chỉ đơn giản là

"}
""

Mà chuyển tất cả các giá trị sang ngăn xếp phụ trợ. Điều này là cần thiết bởi vì chúng tôi muốn bắt đầu xử lý các cặp mà chúng tôi đọc đầu tiên. Bây giờ vòng lặp cuối cùng:

:{"
{ $;
)";.

Chỉ )cần tăng một số giá trị giả để đảm bảo rằng nó dương và con trỏ lệnh quay về hướng bắc. {kéo qua chữ số đầu tiên của cặp tiếp theo và :nhân đôi nó. Bây giờ khi chúng tôi xử lý xong, đây sẽ là một 0từ dưới cùng của ngăn xếp phụ trợ. Nếu không thì nó 48hoặc 49. Trong trường hợp bằng 0, chúng ta thoát khỏi vòng lặp và chấm dứt @, nếu không, IP sẽ quay về hướng đông.

{kéo qua các chữ số khác của cặp hiện tại. $mất XOR giữa chúng. Nếu đó là 0, tức là hai số bằng nhau, IP sẽ tiếp tục di chuyển về phía nam, ;loại bỏ số 0 và IP quay về hướng tây vào lần lặp tiếp theo. Nếu XOR là 1, tức là họ khác nhau, IP chuyển về phía tây, vứt bỏ sự 1với ;và in các chữ số đầu tiên với ..

MATL , 11 9 8 byte

`-?6MD]T

Đầu vào và đầu ra là những con số được phân tách bằng dòng mới. Kết thúc bằng một lỗi (được mặc định cho phép) khi tất cả các đầu vào đã được sử dụng.

Hãy thử trực tuyến!

`         % 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

Cách tiếp cận cũ, 11 byte

2YCd9L)Xz0<

Đầu vào là một chuỗi. Đầu ra là những con số được phân tách bằng dòng mới.

Hãy thử trực tuyến!

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

Ruby, 46 byte

Điều này phân tách l[0], l[1]và l[2..{end}]như a, bvà c. Sau đó, nó tạo ra một chuỗi với aif a!=bhoặc ''nếu không và f[c]nếu c[0]tồn tại hoặc ''khác.

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

Ung dung:

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 byte

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

So với Java, cái này rất nhỏ gọn, tuy nhiên, tôi sợ người trả lời Brainfuck-golfer. Và hãy đề cập đến nếu có lỗi. Giả sử EOF là 0, đầu vào không chứa đầu vào không hợp lệ, ô ban đầu bằng 0 và phạm vi giá trị ô là hữu hạn và tuần hoàn. Không có giả định khác là hiện tại.

Giải trình:

Bản đồ di động bộ nhớ

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

Chỉ dẫn

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

Toán học, 41 byte

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

Hàm ẩn danh đầu vào và đầu ra danh sách các số không và số không.

Bình thường, 10 byte

hMf!qFTcz2

Bộ kiểm tra

C, 66 byte

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

Giả định sizeof(int) == sizeof(char *)

Giải pháp "thông minh" - 84 81 byte

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

Hoạt động trên máy endian nhỏ giả sử shortlà 2 byte. Đầu vào được thông qua như là đối số. Chương trình lặp lại qua các cặp ký tự và in 0 cho 0x3130 và 1 cho 0x3031. Trên big-endian, kết quả sẽ bị đảo ngược (thay thế 48|c&1bằng 49^c&1để sửa lỗi này).

C, 57 byte

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

Chúng tôi tạm thời sao chép một ký tự từ đầu vào psang kết quả r, nhưng chỉ tiến rcon trỏ nếu nó khác với ký tự tiếp theo. Nếu không, sau đó chúng tôi sẽ ghi đè lên nó ở cặp chưa từng có tiếp theo hoặc NULở cuối.

Chương trình kiểm tra:

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

Đầu ra thử nghiệm:

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

Befunge-93 , 40 byte

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

Bạn có thể thử nó ở đây . Dán mã vào khoảng trống dưới nút "hiển thị", nhấn "hiển thị", xác định đầu vào, nhấn "chạy". Chúng tôi sử dụng nút "bước" để xem chương trình hoạt động như thế nào.

DOS / Windows Batch, 201 162 byte

@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

Đầu vào là một chuỗi tách biệt không gian, ví dụ 1 0 0 1 1. Bắt đầu từ cmd, nếu không màn hình sẽ thoát ngay lập tức

sáp ong ,45 35 byte

Tôi có thể đánh nó xuống 10 byte, không quá tệ.

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

Tôi đã đọc một chuỗi đầy đủ các cách tiếp cận tung đồng xu , điều này làm cho chương trình khá lớn. Chỉ cần đọc từng số nguyên một sẽ làm cho chương trình nhỏ hơn có thể khoảng 22 byte hoặc hơn nữa nhưng cũng rất bất tiện khi sử dụng.

Ví dụ:

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!

Kho lưu trữ sáp ong GitHub của tôi.

Ví dụ sáp ong của tôi về Rosetta Code.