Anda memiliki koin yang menghasilkan 0atau 1. Tetapi Anda mencurigai koin itu bias , artinya kemungkinan 0(atau 1) tidak harus 1/2.

Sebuah terkenal prosedur untuk "mengubah" koin bias menjadi koin (yaitu untuk mendapatkan hasil yang sama mungkin), seperti yang diusulkan oleh von Neumann, adalah sebagai berikut. Menghasilkan (tidak tumpang tindih) blok dari dua lemparan koin sampai dua nilai blok berbeda; dan output nilai pertama di blok itu (nilai kedua juga akan dilakukan, tetapi untuk tujuan tantangan ini kita memilih yang pertama). Secara intuitif, 1mungkin lebih mungkin daripada 0, tetapi 01dan 10akan sama mungkin.

Misalnya, input 1110...akan membuang blok pertama, lalu menghasilkan 1dari blok kedua, ...

Prosedur ini mahal , karena beberapa lemparan koin dikonsumsi untuk menghasilkan hasil tunggal.

Tantangan

Ambil urutan nol dan satu yang terbatas, mewakili lemparan koin asli, dan hasilkan jumlah hasil maksimum sesuai dengan prosedur di atas, sampai semua input dikonsumsi.

Blok terakhir mungkin tidak lengkap, jika jumlah nilai input ganjil. Misalnya, urutan input tidak 11111akan menghasilkan hasil (dua blok pertama memiliki nilai yang sama, dan blok ketiga tidak lengkap).

Aturan

Input dapat memiliki jumlah nilai non-negatif, tidak harus positif atau bahkan.

Format input mungkin:

• sejumlah nol dan satu;
• string nol dan yang dengan pemisah opsional.

Format output mungkin:

• serangkaian nol dan satu, dengan atau tanpa pemisah;
• sejumlah nol dan satu;
• string yang mengandung nol tunggal atau satu, dipisahkan oleh baris baru;
• format serupa yang wajar dan sesuai dengan bahasa Anda.

Golf kode. Bytes paling sedikit menang.

Uji kasus

Input dan output di sini diasumsikan sebagai string.

Input         -->  Output

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

Jelly, 6 byte

s2Q€Ṗ€

Cobalah online!

Bagaimana itu bekerja

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.

Retina , 16 14 byte

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

Cobalah online!

Penjelasan

Ini cukup sederhana. Kode mendefinisikan satu penggantian substitusi tunggal menggantikan semua kecocokan (tidak tumpang tindih) (.)\1|(.)?.dengan apa pun yang ditangkap kelompok kedua. Ini menggabungkan tiga kasus berbeda menjadi satu:

(.)\1 --> <empty>

Jika dua digit berulang sama, kami menghapusnya dari string (karena grup 2 tidak digunakan).

(.).  --> $2

Kalau tidak, jika kita dapat mencocokkan dua karakter, hapus yang kedua, dengan mengganti keduanya dengan yang pertama. Jika bukan itu masalahnya maka ?akan menghilangkan grup:

.     --> <empty>

Ini hanya terjadi jika ada karakter trailing tidak berpasangan, yang juga dihapus.

Labirin , 21 12 byte

"(. :
""*$,@

Contoh langka dari program Labirin kompak yang juga tidak memiliki larangan. Di |versi sebelumnya sama sekali tidak perlu, dan menghapusnya secara besar-besaran mengurangi ukuran program. Faktanya, Lab mengalahkan Retina!

Cobalah online!

Kiri bawah "juga bisa menjadi ruang, tetapi memiliki di sana sangat menyederhanakan penjelasan.

Penjelasan

Yang ini agak rumit, jadi disertai dengan gambar. Tapi pertama-tama, primer cepat:

• Labyrinth adalah bahasa 2D berbasis stack. Memori terdiri dari tumpukan utama dan tumpukan tambahan.
• Tumpukan Labyrinth tidak memiliki dasar dan diisi dengan angka nol, jadi melakukan operasi pada tumpukan kosong bukanlah kesalahan.
• Di setiap persimpangan, di mana ada dua atau lebih jalur untuk penunjuk instruksi untuk pergi, bagian atas tumpukan utama diperiksa untuk mencari tahu ke mana harus pergi selanjutnya. Negatif belok kiri, nol lurus ke depan dan positif belok kanan. Jika belokan gagal, penunjuk mencoba berbelok ke arah lain.

Mendirikan

Program dimulai di kiri atas ", yang merupakan no-op. Lalu kami melakukan:

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

Ini meninggalkan tumpukan dengan 0 tunggal di atasnya, yang sama baiknya dengan kosong untuk keperluan Labirin.

Masukan dan terminasi bacaan

,membaca char dari input, menghasilkan 48 atau 49 untuk 0atau 1masing - masing, dan -1 pada EOF. Karena ini bukan nol, bagaimanapun kita berubah menjadi: , yang menduplikasi bagian atas tumpukan.

Jalan :buntu, jadi kami berbalik dan mengeksekusi ,sekali lagi. Sekarang jika input terakhir adalah EOF, maka kita berbelok ke kiri dan mengakhiri dengan @, kalau tidak kita berbelok ke kanan, dengan tumpukan tampak seperti [a a b](di mana a, badalah dua karakter).

Menafsirkan lemparan koin

Jika kami tidak berhenti, langkah selanjutnya adalah mengeksekusi $(bitwise xor) lagi. Ini menghasilkan 0 jika karakter inputnya sama, 1 sebaliknya. Kami kemudian gandakan adengan hasil ini, memberikan 0 atau a. Sejak* berada di persimpangan, nilai tumpukan teratas ini menentukan apa yang terjadi selanjutnya.

Dalam 0 case, kita langsung saja menjalankan tiga "no-ops, sebelum melakukan (decrement. Seperti pengaturan, ini membuat kita berbalik dan mengeksekusi "*$, membuat kita siap untuk membaca lebih banyak karakter.

Kalau tidak, dalam akasus ini, kita belok kanan di persimpangan karena apositif (48 atau 49). .output char, membiarkan stack kosong, dan (mengurangi bagian atas stack, memutar 0 ke -1. Sekali lagi, ini membuat kita berbelok ke kiri, menjalankan "*$seperti pada pengaturan, juga membuat kita siap untuk membaca lebih banyak input.

CJam, 10 8 byte

l2/{)-}%

Uji di sini.

Penjelasan

Ini adalah solusi yang sangat sederhana: di setiap pasangan, hapus semua instance dari karakter terakhir. Digit berulang dan digit trailing tidak berpasangan akan dihapus, seperti halnya digit kedua dari setiap pasangan digit yang tidak sama:

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

Ini hanya menyisakan digit yang kita cari. Inilah cara kode menghitung ini:

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

Ketika daftar dicetak secara otomatis di akhir program, string kosong dihilangkan.

Perl, 19 18 17 byte

Solusi @Martin Büttner Retina menginspirasi gain 2 byte

Termasuk +1 untuk -p

Jalankan dengan input pada STDIN, mis perl -p fair.pl <<< 11000110

fair.pl:

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

Tidak banyak yang bisa dijelaskan di sini karena ini merupakan terjemahan spesifikasi (tidak langsung):

• (.)\1 Jika 2 digit pertama sama, jatuhkan
• .\K. Kalau tidak, dua digit pertama berbeda. Simpan ( \K) yang pertama
• .?\K.Kecuali bahwa yang pertama .adalah opsional. Hal ini memungkinkan untuk satu pertandingan di ujung string yang kemudian dibuang karena bagian yang disimpan kosong

Mathematica, 36 38 byte

-2 setelah mencuri fungsi @ LegionMammal978 untuk menentukan apakah daftar 2-elemen adalah {0,1} atau {1,0}

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

Argumen diharapkan menjadi daftar bilangan bulat.

Hexagony , 23 21 byte

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

Dibuka:

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

Ini berakhir dengan kesalahan, tetapi pesan kesalahan pergi ke STDERR.

Cobalah online!

Menilai dari jumlah mirror, mungkin saja cukup untuk memasangnya menjadi side-length 3 tapi sejauh ini saya belum beruntung.

Penjelasan

Berikut diagram yang biasa, dihasilkan dengan HexagonyColorer Timwi :

Program ini hanya menggunakan tiga sisi memori, diberi label A , B , dan C di sini (diagram milik Timwi's EsotericIDE ):

Eksekusi dimulai di jalur biru. The /hanya cermin yang mengarahkan pointer instruksi (IP), kode aktual adalah:

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

The ,akan mengatur tepi untuk -1bukan kode karakter jika kita telah memukul EOF. Karena kami menambah kedua input yang tidak mengubah apakah mereka sama atau tidak, tetapi mengubah EOF menjadi 0.

Kami menggunakan modulo untuk memeriksa persamaan, karena itu 1atau 49(positif) untuk karakter yang tidak sama dan 0karakter yang sama. Ini juga berfungsi sebagai akhir dari program, karena ketika kita memiliki 0dari EOF, pembagian yang dicoba dengan nol akan menyebabkan kesalahan.

Sekarang yang <membedakan nol dari hasil positif. Yang sederhana pertama: jika karakternya sama, IP mengambil jalur merah. _adalah cermin, \juga cermin tetapi diabaikan, dan >membelokkan IP sedemikian rupa sehingga membungkus tepi dan mulai dari atas lagi. Namun, pada iterasi ini, peran A , B dan C bertukar secara siklis ( C sekarang mengambil peran A dan seterusnya).

Jika karakter berbeda, jalur hijau diambil sebagai gantinya. Yang ini agak berantakan. Pertama-tama melompati no-op dengan $, kemudian membungkus ke sekitar /di tepi kiri, kemudian melintasi baris kedua-ke-terakhir dari kanan ke kiri dan akhirnya kembali memasuki bagian yang menarik dari kode sumber di {. Ada sedikit kode yang pada dasarnya linier, yang akan saya jelaskan sebentar lagi, sebelum $IP melompati >untuk menggabungkan dua jalur lagi.

Inilah potongan kode linear:

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

Perhatikan bahwa dalam kasus ini, peran tepi untuk iterasi berikutnya juga ditukar secara siklikal, tetapi dengan B mengambil peran A dan seterusnya.

Haskell, 71 44 29 byte

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

Golf ekstrim oleh nimi .

> <> , 11 byte

i:i:0(?;-?o

> <> sangat cocok untuk tantangan membaca-a-char-at-a-time seperti ini :) Coba online!

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)

Ini semua terjadi dalam satu lingkaran karena pointer instruksi membungkus begitu mencapai akhir baris.

Python, 42 byte

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

Bersenang-senang dengan rekursi dan bitor xor. Mengambil daftar 1s dan 0s sebagai input.

JavaScript (ES6), 33 byte

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

Bagaimana itu bekerja

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.

Pendahuluan , 12 byte

11(-(#!)?^?)

Ini mengasumsikan seorang juru bahasa yang membaca dan mencetak karakter. Anda dapat mengurutkannya secara online. Tapi juru bahasa itu mencetak bilangan bulat, jadi untuk setiap 0Anda akan mendapatkan 48dan untuk masing-masing 1Anda akan mendapatkan 49sebaliknya (dan linefeed).

Penjelasan

Sangat jarang Anda dapat menulis program non-sepele pada satu baris di Prelude (karena Prelude membutuhkan lebih dari satu baris untuk menyelesaikan 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 ditambahkan untuk -nbendera.

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

Uji:

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

1



1101001
0
1011101010
1111

Terima kasih kepada @TonHospel untuk 6 byte!

Menuju 93 , 16 byte

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

Satu liner untuk kekompakan. Diuji menggunakan juru bahasa online ini .

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

Bagian terakhir memanfaatkan fakta itu muncul dari tumpukan Befunge-93 yang kosong menghasilkan 0 .

Jika a != b, kami tampil

>                      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

Kalau tidak, jika a == b, kami melakukan:

>                      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 byte

jkPM{Mcz2

Algoritma dicuri tanpa malu-malu dari jawaban Dennis's 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 []

Python 2, 48 byte

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

Cobalah online

Terima kasih untuk Dennis dan vaultah karena menunjukkan hal-hal yang saya lewatkan

Mathematica, 41 39 byte

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

Kurang rumit dan lebih pendek dari jawaban lainnya. Kotak adalah karakter transpose.

JavaScript (ES6), 33 byte

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

Port yang membosankan dari jawaban Retina.

sed, 34 33 byte

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

Uji:

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

1



1101001
0
1011101010
1111

Labirin , 31 byte

Tidak sesingkat dan serapi solusi Sp3000, tapi saya pikir saya tetap akan memposting ini sebagai pendekatan yang berbeda:

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

Penjelasan

Loop pertama sederhana

""
,,

yang bertuliskan dua karakter sekaligus ( "tidak ada op). Setelah EOF, ,akan kembali -1, tetapi hanya memeriksa EOF di setiap karakter kedua. Itu berarti dalam hal apapun bagian atas tumpukan kemudian akan menjadi -1dan nilai di bawahnya adalah baik-1 atau beberapa kode karakter yang tidak kita pedulikan, karena itu adalah lemparan koin yang tidak berpasangan.

Kemudian )*ubah -1dan nilai di bawah ini menjadi tunggal 0yang kita perlukan a) untuk menyingkirkan kedua nilai tersebut dan b) untuk memasukkan loop berikutnya dengan benar. Lingkaran berikutnya itu sederhana

"}
""

Yang menggeser semua nilai ke tumpukan tambahan. Ini diperlukan karena kami ingin mulai memproses pasangan yang kami baca terlebih dahulu. Sekarang loop terakhir:

:{"
{ $;
)";.

The )hanya penambahan beberapa nilai dummy untuk memastikan bahwa itu positif dan instruksi pointer bergantian utara. {menarik digit pertama dari pasangan berikutnya dan :menduplikatnya. Sekarang ketika kita selesai memproses, ini akan menjadi 0dari dasar tumpukan tambahan. Kalau tidak salah 48atau 49. Dalam hal nol, kita keluar dari loop dan berakhir@ , jika tidak, IP berbelok ke timur.

{menarik digit lain dari pasangan saat ini. $mengambil XOR di antara mereka. Jika itu 0, yaitu keduanya sama, IP hanya terus bergerak ke selatan, ;membuang nol, dan IP berubah ke barat ke iterasi berikutnya. Jika XOR itu 1, yaitu mereka berbeda, IP berubah menjadi barat, membuang 1dengan ;dan mencetak digit pertama dengan ..

MATL , 11 9 8 byte

`-?6MD]T

Input dan output adalah angka yang dipisahkan oleh baris baru. Berakhir dengan kesalahan (diizinkan secara default) ketika semua input telah dikonsumsi.

Cobalah online!

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

Pendekatan lama, 11 byte

2YCd9L)Xz0<

Input adalah sebuah string. Output adalah angka yang dipisahkan oleh baris baru.

Cobalah online!

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

Ini memisahkan l[0], l[1]dan l[2..{end}]sebagai a, bdan c. Kemudian ia menciptakan string dengan ajika a!=batau ''sebaliknya dan f[c]jika c[0]ada atau ''sebaliknya.

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

Tidak Disatukan:

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

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

Dibandingkan dengan Jawa, ini sangat ringkas, namun, saya takut dengan penjawab brainfuck-pegolf. Dan jangan ragu untuk menyebutkan jika ada bug. Dengan asumsi EOF adalah 0, input tidak mengandung input yang tidak valid, sel awalnya nol, dan rentang nilai sel terbatas dan siklik. Tidak ada asumsi lain.

Penjelasan:

Peta Sel Memori

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

Petunjuk

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

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

Fungsi anonim yang input dan output daftar nol dan yang.

Pyth, 10 byte

hMf!qFTcz2

Suite uji

C, 66 byte

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

Asumsi sizeof(int) == sizeof(char *)

"pintar" solusi - 84 81 byte

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

Bekerja pada mesin little-endian dengan asumsi short2 byte. Masukan diberikan sebagai argumen. Program ini mengulangi pasangan karakter dan mencetak 0 untuk 0x3130 dan 1 untuk 0x3031. Pada big-endian hasilnya akan terbalik (ganti 48|c&1dengan 49^c&1untuk memperbaikinya).

C, 57 byte

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

Kami sementara menyalin karakter dari input pke hasil r, tetapi hanya memajukan rpointer jika berbeda dari karakter berikutnya. Jika tidak, maka kami akan menimpanya di pasangan yang tidak cocok berikutnya, atau dengan NULdi akhir.

Program uji:

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

Hasil tes:

$ ./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+:|
^     <  @

Anda bisa mencobanya di sini . Tempel kode di ruang di bawah tombol "tampilkan", tekan "tampilkan", tentukan input, tekan "jalankan". Kami menggunakan tombol "langkah" untuk melihat cara kerja program.

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

Input adalah string yang dipisahkan ruang, misalnya 1 0 0 1 1. Mulai dari cmd, jika tidak layar segera keluar

lilin lebah ,45 35 byte

Saya bisa menurunkannya dengan 10 byte — tidak terlalu buruk.

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

Saya mengambil bacaan penuh dengan pendekatan lemparan koin , yang membuat program ini cukup besar. Hanya dengan membaca bilangan bulat satu per satu akan membuat program lebih kecil — mungkin sekitar 22 byte atau lebih — tetapi juga sangat tidak nyaman untuk digunakan.

Contoh:

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!

Gudang lilin GitHub saya.

Contoh lilin lebah saya di Rosetta Code.