Üreten bir bozuk para var 0ya da 1. Ancak madalyonun önyargılı olabileceğinden şüpheleniyorsunuz, bu da 0(veya 1) olasılığının mutlaka 1/2 olmadığı anlamına geliyor.

Bir iyi bilinen bir halinde, bir eğimli para "dönüştürme" prosedürü bol para von Neumann önerdiği gibi, (örneğin, eşit olasılıkla sonuçları elde etmek için), aşağıdaki gibi olan. Bir bloğun iki değeri farklı oluncaya kadar iki bozuk para fırlatmanın bloklarını (üst üste binmeyen) üretin; ve bu bloktaki ilk değeri (ikinci değer de yapar, ancak bu zorluğun amaçları için ilkini seçeriz) çıkar. Sezgisel, 1daha muhtemel olabilir 0, ancak 01ve 10eşit olasılığı artacaktır.

Örneğin, giriş 1110...ilk bloğu atar, ardından 1ikinci bloğu a'dan bir ...

Bu prosedür pahalıdır , çünkü tek bir sonuç elde etmek için birkaç jeton fırlatıcısı tüketilir.

Meydan okuma

Orijinal madalyonun atışlarını temsil eden sonlu bir sıfırlar ve sayılar dizisini alın ve tüm girdiler tüketilene kadar yukarıdaki prosedüre göre maksimum sonuç sayısını üretin .

Girdi değerlerinin sayısı tek ise son blok eksik olabilir. Örneğin, giriş dizisi 11111sonuç vermeyecektir (ilk iki blok eşit değerlere sahiptir ve üçüncü blok eksiktir).

kurallar

Girdi, negatif veya kesin olmayan değerlere sahip olabilir, mutlaka pozitif veya eşit olmayabilir.

Giriş formatı şöyle olabilir:

• bir dizi sıfır ve sıfır;
• isteğe bağlı bir ayırıcıya sahip sıfırlar ve olanlar.

Çıkış formatı olabilir:

• ayırıcı olan veya olmayan bir sıfır ve sıfır dizisi;
• bir dizi sıfır ve sıfır;
• newlines ile ayrılmış, tek bir sıfır veya bir içeren dizeler;
• Dilinize uygun herhangi bir benzer, makul format.

Kod golfü. En az bayt kazanır.

Test durumları

Burada girdi ve çıktı dizge olarak kabul edilir.

Input         -->  Output

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

Jöle, 6 bayt

s2Q€Ṗ€

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

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

Çevrimiçi deneyin!

açıklama

Bu oldukça basittir. Kod, (üst üste binmeyen) tüm eşleşmeleri (.)\1|(.)?., ikinci grupta toplananlar ile değiştirerek tek bir regex ikamesi tanımlar . Bu üç farklı durumu bir araya getirir:

(.)\1 --> <empty>

Tekrarlanan iki hane eşitse, onları dizeden kaldırırız (çünkü grup 2 kullanılmaz).

(.).  --> $2

Aksi takdirde, iki karakterle eşleşebilirsek, ikincisini, ikisini de birincisiyle değiştirerek kaldırın. Durum böyle değilse ?grubu atlayacaktır:

.     --> <empty>

Bu, ancak aynı zamanda kaldırılmış eşleştirilmemiş bir iz karakteri varsa oluşur.

Labirent , 21 12 bayt

"(. :
""*$,@

Ayrıca hiçbir op-op olmayan kompakt bir Labirent programının nadir bir örneği. |Önceki sürümde tamamen gereksiz ve ağır programın boyutu azaltılmış çıkarılması. Aslında, Lab Retina'yı dövüyor!

Çevrimiçi deneyin!

Sol alt "kısım da bir boşluk olabilir, ancak orada olması açıklamayı büyük ölçüde basitleştirir.

açıklama

Bu biraz daha hileli, bu yüzden görüntüler eşlik ediyor. Ama önce hızlı bir astar:

• Labirent, yığın tabanlı bir 2B dilidir. Bellek bir ana yığından ve yardımcı yığından oluşur.
• Labirentin yığınları dipsiz ve sıfırlarla dolu, bu nedenle boş bir yığın üzerinde işlem yapmak bir hata değildir.
• Talimat göstericisinin gitmesi için iki veya daha fazla yolun bulunduğu her kavşakta, ana yığının tepesi, nereye gidileceğini bulmak için kontrol edilir. Negatif sola, sıfır dümdüz ve pozitif sağa döner. Bir dönüş başarısız olursa, işaretçi diğer yöne dönmeye çalışır.

Kurmak

Program sol üstte başlıyor ", ki bu işlem yapılmadı. Ardından gerçekleştiririz:

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

Bu, yığını üzerine tek bir 0 bırakarak Labyrinth'in amaçları için boştur.

Giriş okuma ve sonlandırma

,48 ya da 49 için dönen girişinden bir char okur 0ya da 1sırasıyla -1 EOF ile. Bu sıfır olmadığından, her iki şekilde :de, yığının tepesini kopyalayana dönüşürüz.

:Arkamızı döner ve yürütmek böylece, ölü sonunda ,bir kez daha. Geçen giriş EOF olsaydı Şimdi, o zaman sola ve ile sona @, başka biz gibi bakarak yığını, sağa [a a b](burada a, biki karakter vardır).

Bozuk para atma yorumlanması

Eğer sonlandırmazsak, sıradaki hamlemiz $tekrar (bitwise xor) yürütmektir . Eğer giriş karakterleri aynı ise 1, aksi takdirde 1 verir. Daha sonra abu sonucu çarparak 0 ya da veririz a. Bu yana *bir birleşme olan, bu üst yığın değeri yanında ne olacağını belirler.

0 durumunda, dümdüz ilerleriz ve "bir (düşüş yapmadan önce üç no-op uygularız. Kurulum gibi, bu da bizi "*$daha fazla karakter okumaya hazır bırakarak çevirip yürütmemizi sağlıyor.

Aksi takdirde, olumlu adurumda aolduğundan kavşakta sağa döneriz (48 veya 49). .char'i çıktırarak yığını boş bırakır ve yığının (tepesini 0 ila -1 döndürerek azaltır. Bir kez daha, bu bizi sola döndürür "*$, kurulumdaki gibi çalışır, ayrıca daha fazla girdi okumaya hazır hale getirir .

CJam, 10 8 bayt

l2/{)-}%

Burada test et.

açıklama

Bu çok basit bir çözüm: her çiftte, son karakterin tüm örneklerini kaldırın. Tekrarlanan rakamlar ve eşleştirilmemiş son rakamlar, herhangi bir eşitsiz rakam çiftindeki ikinci rakam gibi kaldırılacaktır:

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

Bu sadece aradığımız rakamları bırakır. İşte kod bu şekilde hesaplar:

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

Liste programın sonunda otomatik olarak yazdırıldığında, boş dizeler basit bir şekilde atlanır.

Perl, 19 18 17 bayt

@Martin Büttner Retina çözümü 2 byte kazanç sağladı

İçin +1 içerir -p

STDIN'deki giriş ile çalıştırın, örn. perl -p fair.pl <<< 11000110

fair.pl:

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

Şartnamenin (dolaylı) bir çevirisi olduğundan açıklamak için çok fazla bir şey yok:

• (.)\1 İlk 2 hane aynıysa, bırak
• .\K. Aksi halde, ilk iki hane farklıdır. İlkini tut ( \K)
• .?\K.Bunun dışında ilk .isteğe bağlı. Bu, dizenin sonunda, tutulan kısım boş olduğu için atılan tek bir eşleşmeye izin verir.

Mathematica, 36 38 bayt

@ LegionMammal978'in 2 elemanlı bir listenin {0,1} veya {1,0} olup olmadığını belirleme fonksiyonunu çaldıktan sonra -2

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

Argümanın bir tamsayı listesi olması bekleniyor.

Altıgen , 23 21 bayt

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

Kırımsız:

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

Bu bir hata ile sonlanır, ancak hata mesajı STDERR'ye gider.

Çevrimiçi deneyin!

Ayna sayısına bakılırsa, onu boyuna 3 sığdırmak mümkün olabilir ama şu ana kadar şansım olmadı.

açıklama

Timwi'nin HexagonyColorer'ı ile oluşturulan genel şema :

Program, burada A , B ve C olarak adlandırılan sadece üç bellek kenarını kullanır (Timwi'nin Ezoterik'in izniyle şema ):

Yürütme mavi yolda başlar. /Yönerge işaretçisi (IP) yönlendirme sadece aynalar vardır, gerçek kodudur:

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

,Uca ayarlayacaktır -1biz EOF isabet verdiyseniz yerine karakter kodunun. Eşit olup olmadıklarını değiştirmeyen her iki girişi de arttırdığımız için, ancak EOF'yi dönüştürür 0.

Eşitliği kontrol etmek için modulo kullanıyoruz, çünkü eşit olmayan karakterler ve eşit karakterler için ya ya 1da 49(pozitif) 0. Aynı zamanda programın sonu olarak da hizmet eder, çünkü 0EOF'den elimizde olduğunda , sıfıra bölünme girişimi bir hataya neden olacaktır.

Şimdi <sıfırları pozitif sonuçlardan ayırt ediyor. Önce basit olanı: eğer karakterler eşitse, IP kırmızı yolu alır. _bir aynadır, \aynı zamanda bir aynadır, ancak göz ardı edilir ve >IP'yi, kenarlarının etrafına dolanacak şekilde tekrar yukarı doğru başlayacak şekilde saptırır. Bununla birlikte, bu yinelemede, A , B ve C'nin rolleri döngüsel olarak değiştirilir ( C şimdi A ve benzeri rol alır ).

Karakterler farklıysa, bunun yerine yeşil yol alınır. Bu biraz daha karışık. Önce no-op'la zıplar $, sonra /sol kenardan sarar , sonra ikinci-son sırayı sağdan sola geçirir ve son olarak kaynak kodunun ilginç kısmına tekrar girer {. $IP'yi >iki yolu tekrar birleştirmek için atlamadan önce, birazdan açıklayacağım temelde doğrusal bir kod biti var .

İşte bu doğrusal kod parçası:

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

Bu durumda, bir sonraki yineleme için kenarların rollerinin de döngüsel olarak değiştirildiğini, ancak B'nin A ve benzeri rol aldığını unutmayın .

Haskell, 71 44 29 bayt

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

Nimi ile aşırı golf .

> <> , 11 bayt

i:i:0(?;-?o

> <> böyle bir seferde bir okumaya meydan okumak için oldukça uygun :) Çevrimiçi deneyin!

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üm bunlar bir döngüde gerçekleşir, çünkü komut göstericisi bir satırın sonuna geldiğinde etrafına sarılır.

Python, 42 bayt

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

Özyineleme ve bitwise xor ile eğlenceli. Giriş olarak 1s ve 0s listesini alır.

JavaScript (ES6), 33 bayt

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

Nasıl çalışır

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.

Başlangıç , 12 bayt

11(-(#!)?^?)

Bu, karakterleri okuyan ve yazdıran bir tercüman varsayar. Çevrimiçi olarak deneyebilirsiniz. Ancak bu tercüman tamsayıları yazdırır, böylece 0alacağınız 48her biri ve bunun yerine 1alacağınız her biri için 49(ve satır başı).

açıklama

Prelude'deki tek satırda önemsiz olmayan bir program yazmanız çok nadirdir (çünkü Prelude'un Turing-tamamlandı için birden fazla satıra ihtiyacı vardır).

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 bayt

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

-nBayrak için bayt eklendi .

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

Ölçek:

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

1



1101001
0
1011101010
1111

6 byte için @TonHospel'e teşekkürler !

Befunge 93 , 16 bayt

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

Kompaktlık için tek astar. Bu çevrimiçi tercüman kullanılarak test edilmiştir .

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

Son kısım, boş bir Befunge-93 yığınından çıkmanın 0 vermesi gerçeğini kullanır .

Eğer a != byaparsak

>                      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

Aksi takdirde a == bgerçekleştirirsek:

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

jkPM{Mcz2

Algoritma, Dennis'in Jelly cevabından utanmadan çalındı .

       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 bayt

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

Çevrimiçi deneyin

Kaçırdığım şeyleri işaret ettiği için Dennis ve Vaultah'a teşekkürler.

Mathematica, 41 39 bayt

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

Diğer cevaplardan daha az karmaşık ve daha kısa. Kutu devrik bir karakterdir.

JavaScript (ES6), 33 bayt

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

Retina cevabının sıkıcı limanı.

sed, 34 33 bayt

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

Ölçek:

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

1



1101001
0
1011101010
1111

Labirent , 31 bayt

Sp3000'ün çözümü kadar kısa ve net değil, ancak yine de farklı bir yaklaşım olarak göndereceğimi düşündüm:

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

açıklama

İlk döngü basit

""
,,

bir kerede iki karakter okuyan (işlem dışı "). EOF'dan sonra ,geri dönecek -1, ancak yalnızca her ikinci karakterde EOF'yi kontrol edecek. Bu, her durumda yığının tepesi olacağı -1ve aşağıdaki değerin ya -1da umursamadığımız bazı karakter kodları olduğu anlamına gelir , çünkü bu eşleştirilmemiş bir bozuk para atmadır.

Sonra )*döner -1ve tek Aşağıdaki değeri 0) bir gereken doğru bir sonraki döngüye girmesine bu iki değer ve b) kurtulmak için. Sonraki döngü basit

"}
""

Bu, tüm değerleri yardımcı yığına kaydırır. Bu gereklidir, çünkü önce okuduğumuz çiftleri işlemeye başlamak istiyoruz. Şimdi son döngü:

:{"
{ $;
)";.

)Sadece artışlarla bazı kukla değeri sonuç pozitif ve talimat işaretçisi dönüşler kuzey sağlamak için. {sonraki çiftin ilk basamağını çeker ve :çoğaltır. Şimdi işlemeyi tamamladığımızda, bu 0yardımcı yığınının dibinden olacaktı . Aksi takdirde ya 48da 49. Sıfır durumunda, döngüden çıkar ve sonlandırırız @, aksi takdirde IP doğuya döner.

{geçerli çiftin diğer basamağını üzerine çeker. $XOR'u aralarında alır. Eğer bu 0 ise, yani ikisi eşitse, IP sadece güneye devam eder ;, sıfırı atar ve IP bir sonraki tekrarlamaya batıya döner. XOR olsaydı 1, yani onlar IP atar, batı döner, farklı 1olan ;ve ilk basamak yazdırır ..

MATL , 11 9 8 bayt

`-?6MD]T

Giriş ve çıkış, yeni satırlarla ayrılmış sayılardır. Tüm girişler tüketildiğinde, hatayla sona erer (varsayılan olarak izin verilir).

Çevrimiçi deneyin!

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

Eski yaklaşım, 11 bayt

2YCd9L)Xz0<

Giriş bir dizedir. Çıktı, yeni satırlarla ayrılmış sayılardır.

Çevrimiçi deneyin!

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 bayt

Bu ayırır l[0], l[1]ve l[2..{end}]olduğu gibi a, bve c. Sonra bir dize oluşturur aeğer a!=byoksa ''başka türlü ve f[c]eğer c[0]mevcutsa veya ''başka türlü.

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

Ungolfed:

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 bayt

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

Java ile karşılaştırıldığında, bu çok kompakt, ancak, beyinbalığı golfçü cevaplayıcı korkuyorum. Ve bir böcek olup olmadığını söylemekten çekinmeyin. EOF'nin 0 olduğu varsayılırsa, giriş geçersiz girdi içermez, hücre başlangıçta sıfırdır ve hücre değer aralığı sonlu ve döngüseldir. Başka bir varsayım yok.

Açıklama:

Bellek Hücresi Haritası

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

Talimat

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

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

Sıfırlar ve sayılar listelerini girip çıkaran adsız işlev.

Pyth, 10 bayt

hMf!qFTcz2

Test odası

C, 66 bayt

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

varsayarsak sizeof(int) == sizeof(char *)

"zeki" çözüm - 84 81 bayt

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

Küçük-endian makinesinde çalışır short, 2 bayttır. Girdi argüman olarak iletildi. Program, karakter çiftleri üzerinde yinelenir ve 0x3130 için 0 ve 0x3031 için 1 olarak yazdırılır. Big-endian'da sonuç tersine çevrilecektir ( bunu düzeltmek için 48|c&1ile değiştirin 49^c&1).

C, 57 bayt

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

Girişten psonuca bir karakteri geçici olarak kopyalarız r, ancak yalnızca bir rsonraki karakterden farklıysa işaretçiyi ilerletiriz . Olmazsa, bir sonraki eşleşmemiş çiftin üzerine veya NULsonunda yazacağız .

Test programı:

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

Test çıkışı:

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

Befunge-93 , 40 bayt

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

Sen edebilirsiniz burada deneyin . Kodu "show" düğmesinin altındaki alana yapıştırın, "show" tuşuna basın, girişi tanımlayın, "run" tuşuna basın. Programın nasıl çalıştığını görmek için "adım" düğmesini kullanıyoruz.

DOS / Windows Toplu İş, 201 162 bayt

@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

Giriş, örneğin boşlukla ayrılmış bir dizedir 1 0 0 1 1. Cmd'den başla, aksi takdirde ekran hemen çıkar

balmumu ,45 35 bayt

10 byte kadar golf oynayabilirim - çok fena değil.

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

Çektiğim madalyonun okuma tam dize yaklaşım fırlatır programı oldukça büyük yapar. Tek tek tam sayıların birer birer okunması, programı daha küçük (belki de yaklaşık 22 byte veya daha fazla) fakat aynı zamanda kullanımı çok da zorlaştıracaktır.

Örnekler:

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!

Balmumu GitHub deposu.

Rosetta Code'da balmumu örnekleri.