Masz monetę, która produkuje 0lub 1. Ale podejrzewasz, że moneta może być stronnicza , co oznacza, że ​​prawdopodobieństwo 0(lub 1) niekoniecznie wynosi 1/2.

Dobrze znana procedura „przekształcić” tendencyjnego monety do sprawiedliwego monety (czyli uzyskanie równie prawdopodobnych wyników), w wersji zaproponowanej przez von Neumanna, jest następująca. Wytwarzaj (nie zachodzące na siebie) bloki dwóch rzutów monetą, aż dwie wartości bloku będą się różnić; i wypisz pierwszą wartość w tym bloku (druga wartość też by zrobiła, ale dla celów tego wyzwania wybieramy pierwszą). Intuicyjnie 1może być bardziej prawdopodobne 0, ale 01i 10równie prawdopodobne.

Na przykład dane wejściowe 1110...odrzuciłyby pierwszy blok, a następnie wygenerowałyby 1z drugiego bloku, ...

Ta procedura jest droga , ponieważ do wygenerowania jednego wyniku zużywa się kilka rzutów monetą.

Wyzwanie

Weź skończoną sekwencję zer i jedynek, reprezentujących rzuty oryginalnej monety, i uzyskaj maksymalną liczbę wyników zgodnie z powyższą procedurą, aż do wyczerpania całego wkładu.

Ostatni blok może być niekompletny, jeśli liczba wartości wejściowych jest nieparzysta. Na przykład sekwencja wejściowa 11111nie dałaby rezultatu (pierwsze dwa bloki mają równe wartości, a trzeci blok jest niekompletny).

Zasady

Dane wejściowe mogą mieć dowolną nieujemną liczbę wartości, niekoniecznie dodatnią, a nawet parzystą.

Format wejściowy może być:

• tablica zer i jedynek;
• ciąg zer i jedynek z opcjonalnym separatorem.

Format wyjściowy może być:

• ciąg zer i jedynek, z separatorami lub bez;
• tablica zer i jedynek;
• ciągi zawierające pojedyncze zero lub jeden, oddzielone znakami nowej linii;
• każdy podobny, rozsądny format, który pasuje do twojego języka.

Kod golfa. Wygrywa najmniej bajtów.

Przypadki testowe

Zakłada się, że dane wejściowe i wyjściowe są ciągami.

Input         -->  Output

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

Galaretka, 6 bajtów

s2Q€Ṗ€

Wypróbuj online!

Jak to działa

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.

Siatkówka , 16 14 bajtów

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

Wypróbuj online!

Wyjaśnienie

To jest dość proste. Kod definiuje pojedyncze podstawienie wyrażenia regularnego, które zastępuje wszystkie (nie nakładające się) dopasowania (.)\1|(.)?.dowolną przechwyconą drugą grupą. Łączy to trzy różne przypadki w jeden:

(.)\1 --> <empty>

Jeśli dwie powtarzające się cyfry są równe, usuwamy je z łańcucha (ponieważ grupa 2 nie jest używana).

(.).  --> $2

W przeciwnym razie, jeśli uda nam się dopasować dwa znaki, usuń drugi, zastępując oba z nich pierwszym. Jeśli tak nie ?jest, grupa pominie:

.     --> <empty>

Dzieje się tak tylko wtedy, gdy występuje sparowany znak końcowy, który również jest usuwany.

Labirynt , 21 12 bajtów

"(. :
""*$,@

Rzadki przykład kompaktowego programu Labirynt, który również nie ma żadnych operacji. |W poprzedniej wersji było całkowicie zbędne, a usunięcie go znacznie zmniejszyć rozmiar programu. W rzeczywistości laboratorium bije siatkówkę!

Wypróbuj online!

Lewy dolny róg " może również być spacją, ale umieszczenie go tam znacznie upraszcza wyjaśnienie.

Wyjaśnienie

Ten jest trochę trudniejszy, więc towarzyszą mu obrazy. Ale najpierw szybki podkład:

• Labirynt to język 2D oparty na stosie. Pamięć składa się ze stosu głównego i stosu pomocniczego.
• Stosy Labiryntu są bez dna i wypełnione zerami, więc wykonywanie operacji na pustym stosie nie jest błędem.
• Na każdym skrzyżowaniu, gdzie znajdują się dwie lub więcej ścieżek dla wskaźnika instrukcji do przejścia, góra stosu głównego jest sprawdzana, aby dowiedzieć się, gdzie iść dalej. Negatyw to skręt w lewo, zero to kierunek na wprost, a dodatni to skręt w prawo. Jeśli zwrot się nie powiedzie, wskaźnik próbuje skręcić w innym kierunku.

Ustawiać

Program rozpoczyna się w lewym górnym rogu ", co oznacza brak operacji . Następnie wykonujemy:

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

To pozostawia stos z pojedynczym 0, co jest tak dobre, jak puste dla celów Labiryntu.

Odczytywanie danych wejściowych i terminacji

,odczytuje karbonizatu z wejściem, powrót do 48 lub 49 0lub 1odpowiednio, -1 i EOF. Ponieważ jest to niezerowe, tak czy inaczej zamieniamy się w :, który duplikuje górę stosu.

:Jest przy ślepej uliczce, więc zawrócić i wykonać ,jeszcze raz. Teraz jeśli ostatni wejście było EOF, a następnie skręcamy w lewo i kończą się @, w przeciwnym razie możemy skręcić w prawo, ze stosu wygląda jak [a a b](gdzie a, bto dwa znaki).

Interpretacja rzutu monetą

Jeśli nie zakończymy, naszym następnym ruchem jest wykonanie ponownie $(bitowe xor) ponownie. Daje to 0, jeśli znaki wejściowe były takie same, w przeciwnym razie 1. Następnie mnożymy az tym wynikiem, dając albo 0, albo a. Od czasu* jest na skrzyżowaniu, ta górna wartość stosu określa, co będzie dalej.

W przypadku 0 idziemy przed siebie i wykonujemy trzy operacje "no-op, zanim wykonamy (dekrementację. Podobnie jak konfiguracja, powoduje to, że obracamy się i wykonujemy "*$, pozostawiając nas gotowymi do przeczytania kolejnych znaków.

W przeciwnym razie ana skrzyżowaniu skręcamy w prawo, ponieważ ajest dodatni (48 lub 49). .wyprowadza char, pozostawiając stos pusty, i (zmniejsza jego górną część, zmieniając wartość z 0 na -1. Ponownie powoduje to, że skręcamy w lewo, wykonując "*$jak w konfiguracji, pozostawiając nam także gotowość do przeczytania większej ilości danych wejściowych.

CJam, 10 8 bajtów

l2/{)-}%

Sprawdź to tutaj.

Wyjaśnienie

Jest to bardzo proste rozwiązanie: w każdej parze usuń wszystkie wystąpienia ostatniej postaci. Powtarzane cyfry i niesparowane cyfry końcowe zostaną usunięte, podobnie jak druga cyfra w dowolnej parze nierównych cyfr:

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

Pozostawia to tylko cyfry, których szukamy. Oto jak to oblicza kod:

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

Gdy lista jest automatycznie drukowana na końcu programu, puste ciągi znaków są po prostu pomijane.

Perl, 19 18 17 bajtów

@Martin Büttner Rozwiązanie Retina zainspirowało 2 bajty

Obejmuje +1 dla -p

Uruchom z wejściem na STDIN, np perl -p fair.pl <<< 11000110

fair.pl:

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

Nie wiele do wyjaśnienia, ponieważ jest to (pośrednie) tłumaczenie specyfikacji:

• (.)\1 Jeśli pierwsze 2 cyfry są takie same, upuść je
• .\K. W przeciwnym razie dwie pierwsze cyfry są różne. Keep ( \K) pierwszy
• .?\K.Tyle że pierwszy .jest opcjonalny. Pozwala to na pojedyncze dopasowanie na końcu łańcucha, które następnie zostaje odrzucone, ponieważ zachowana część jest pusta

Mathematica, 36 38 bajtów

-2 po kradzieży funkcji @ LegionMammal978 w celu ustalenia, czy lista 2-elementowa to {0,1} czy {1,0}

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

Argument ma być listą liczb całkowitych.

Sześciokąt , 23 21 bajtów

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

Rozłożony:

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

To kończy się błędem, ale komunikat o błędzie trafia do STDERR.

Wypróbuj online!

Sądząc po liczbie luster, może być prawie możliwe zmieszczenie go w bocznej długości 3, ale jak dotąd nie miałem szczęścia.

Wyjaśnienie

Oto zwykły schemat wygenerowany za pomocą HexagonyColorer Timwi :

Program używa tylko trzech krawędzi pamięci, oznaczonych tutaj A , B i C (schemat dzięki uprzejmości Timoter's EsotericIDE ):

Wykonanie rozpoczyna się na niebieskiej ścieżce. To /tylko mirrory, które przekierowują wskaźnik instrukcji (IP), rzeczywisty kod to:

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

,Ustawi krawędź -1zamiast kodu znaków jeśli mamy hit EOF. Ponieważ zwiększamy oba dane wejściowe, nie zmienia to, czy są one równe, czy nie, ale zmienia EOF w 0.

Używamy modulo celu sprawdzenia równości, bo to albo 1lub 49(pozytywny) na nierównych znaków i 0na równych znaków. Służy również jako koniec programu, ponieważ kiedy mamy0 z EOF, próba dzielenia przez zero spowoduje błąd.

Teraz <odróżnia zera od pozytywnych wyników. Prosty pierwszy: jeśli znaki są równe, adres IP podąża czerwoną ścieżką. _jest lustrem, \jest także lustrem, ale zostaje zignorowane i >odchyla adres IP tak, że owija się wokół krawędzi i zaczyna od nowa od góry. Jednak w tej iteracji role A , B i C są cyklicznie zamieniane ( C przyjmuje teraz rolę A i tak dalej).

Jeśli postacie są różne, zamiast tego wybierana jest zielona ścieżka. Ten jest nieco bardziej chaotyczny. Najpierw przeskakuje przez brak op $, a następnie owija się do /lewej krawędzi, następnie przechodzi od drugiego do ostatniego rzędu od prawej do lewej, a na koniec ponownie wprowadza interesującą część kodu źródłowego na {. Jest zasadniczo liniowy kawałek kodu, który wyjaśnię za sekundę, zanim $IP przeskoczy nad, >aby ponownie połączyć dwie ścieżki.

Oto ten liniowy fragment kodu:

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

Zauważ, że w tym przypadku role krawędzi dla następnej iteracji są również wymieniane cyklicznie, ale B przyjmuje rolę A i tak dalej.

Haskell, 71 44 29 bajtów

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

Ekstremalne golfa przez Nimi .

> <> , 11 bajtów

i:i:0(?;-?o

> <> całkiem dobrze nadaje się do takich wyzwań, jak czytanie char-at-a-time :) Wypróbuj 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)

Wszystko to dzieje się w pętli, ponieważ wskaźnik instrukcji otacza się, gdy osiągnie koniec linii.

Python, 42 bajty

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

Zabawa z rekurencją i bitową xor. Pobiera na wejściu listę 1 i 0.

JavaScript (ES6), 33 bajty

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

Jak to działa

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.

Preludium , 12 bajtów

11(-(#!)?^?)

Zakłada się, że interpreter odczytuje i drukuje znaki. Możesz spróbować w Internecie. Ale ten interpreter wypisuje liczby całkowite, więc dla każdego 0dostaniesz 48i dla każdego 1dostaniesz 49zamiast tego (i linefeed).

Wyjaśnienie

Bardzo rzadko można napisać nietrywialny program w jednym wierszu w Preludium (ponieważ Prelude wymaga więcej niż jednego wiersza, aby 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.
)

Perl, 27 21 bajtów

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

Dodano bajt dla -nflagi.

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

Test:

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

1



1101001
0
1011101010
1111

Dzięki @TonHospel za 6 bajtów!

Befunge 93 , 16 bajtów

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

Jednowarstwowa dla zwartości. Testowane przy użyciu tego internetowego tłumacza .

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

Ostatnia część wykorzystuje fakt, że wyskakiwanie z pustego stosu Befunge-93 daje 0 .

Jeśli a != bwykonamy

>                      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

W przeciwnym razie a == bwykonujemy:

>                      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 bajtów

jkPM{Mcz2

Algorytm bezwstydnie skradziony z galaretki Dennisa .

       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 bajtów

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

Wypróbuj online

Podziękowania dla Dennisa i vaultah za wskazanie rzeczy, które mi umknęły

Mathematica, 41 39 bajtów

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

Mniej skomplikowane i krótsze niż druga odpowiedź. Pole jest znakiem transponującym.

JavaScript (ES6), 33 bajty

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

Nudny port odpowiedzi Retina.

sed, 34 33 bajty

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

Test:

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

1



1101001
0
1011101010
1111

Labirynt , 31 bajtów

Nie tak krótkie i schludne jak rozwiązanie Sp3000, ale pomyślałem, że i tak opublikuję to jako inne podejście:

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

Wyjaśnienie

Pierwsza pętla jest po prostu

""
,,

który odczytuje dwa znaki na raz ( "nie ma operacji ). Po EOF ,powróci -1, ale sprawdza EOF tylko co drugi znak. Oznacza to, że w każdym razie górna część stosu będzie wtedy-1 a wartość poniżej to albo-1 lub jakiś kod znakowy, który nas nie obchodzi, ponieważ jest to niesparowany rzut monetą.

Następnie )*zamienia -1poniższe wartości i w jeden, 0którego potrzebujemy a), aby pozbyć się tych dwóch wartości i b), aby poprawnie przejść do następnej pętli. Ta następna pętla jest po prostu

"}
""

Który przenosi wszystkie wartości na stos pomocniczy. Jest to konieczne, ponieważ chcemy rozpocząć przetwarzanie par, które najpierw czytamy. Teraz ostatnia pętla:

:{"
{ $;
)";.

Po )prostu zwiększa wartość manekina, aby upewnić się, że jest dodatnia, a wskaźnik instrukcji skręca na północ.{przeciąga pierwszą cyfrę następnej pary i :kopiuje ją. Teraz, gdy skończymy przetwarzanie, będzie to 0od dołu stosu pomocniczego. Inaczej to albo 48albo 49. W przypadku zera wychodzimy z pętli i kończymy @, w przeciwnym razie IP skręca na wschód.

{przesuwa drugą cyfrę bieżącej pary. $bierze XOR między nimi. Jeśli jest to 0, tzn. Dwa są równe, IP po prostu kontynuuje przemieszczanie się na południe, ;odrzuca zero, a IP zmienia się na zachód w następną iterację. Jeśli XOR był 1, tzn. Były różne, IP skręca na zachód, odrzuca 1z; i drukuje pierwszą cyfrę z ..

MATL , 11 9 8 bajtów

`-?6MD]T

Dane wejściowe i wyjściowe są liczbami oddzielonymi znakami nowej linii. Kończy się błędem (domyślnie dozwolonym), gdy wszystkie dane zostaną wykorzystane.

Wypróbuj 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

Stare podejście, 11 bajtów

2YCd9L)Xz0<

Dane wejściowe to ciąg znaków. Dane wyjściowe to liczby oddzielone znakami nowej linii.

Wypróbuj 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

Rubinowy, 46 bajtów

Oddziela l[0], l[1]i l[2..{end}]w a, bi c. Następnie tworzy ciąg znaków z, ajeśli a!=blub w ''inny sposób, a f[c]jeśli c[0]istnieje lub w ''inny sposób.

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

Nie golfowany:

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

pieprzenie mózgu, 33 bajty

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

W porównaniu z Javą jest to bardzo kompaktowe, ale obawiam się, że odpowiem na głupców. I nie krępuj się wspomnieć, jeśli występuje błąd. Zakładając, że EOF wynosi 0, dane wejściowe nie zawierają nieprawidłowych danych wejściowych, komórka początkowo wynosi zero, a zakres wartości komórki jest skończony i cykliczny. Nie ma innych założeń.

Wyjaśnienie:

Mapa komórek pamięci

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

Instrukcja

,>,                               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 bajtów

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

Anonimowa funkcja, która wprowadza i wyprowadza listy zer i jedynek.

Pyth, 10 bajtów

hMf!qFTcz2

Zestaw testowy

C, 66 bajtów

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

Zarozumiały sizeof(int) == sizeof(char *)

„sprytne” rozwiązanie - 84 81 bajtów

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

Działa na maszynie little-endian przy założeniu, że shortma 2 bajty. Dane wejściowe są przekazywane jako argument. Program iteruje po parach znaków i wypisuje 0 dla 0x3130 i 1 dla 0x3031. Na grubokońcej zostanie odwrócony wynik (zamiast 48|c&1z 49^c&1to naprawić).

C, 57 bajtów

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

Wstępnie kopiujemy znak z danych wejściowych pdo wyniku r, ale przesuwamy rwskaźnik tylko wtedy, gdy różni się on od następnego znaku. Jeśli nie, zastąpimy go przy następnej niedopasowanej parze lub za pomocąNUL na końcu.

Program testowy:

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

Wyjście testowe:

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

Befunge-93 , 40 bajtów

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

Możesz spróbować tutaj . Wklej kod w spację pod przyciskiem „pokaż”, naciśnij „pokaż”, zdefiniuj dane wejściowe, naciśnij „uruchom”. Używamy przycisku „krok”, aby zobaczyć, jak działa program.

Pakiet DOS / Windows, 201 162 bajtów

@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

Dane wejściowe to na przykład ciąg oddzielony spacją 1 0 0 1 1. Zacznij od cmd, w przeciwnym razie ekran natychmiast się wyłączy

wosk ,45 35 bajtów

Mogłem golfa o 10 bajtów - nieźle.

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

Wziąłem czytania pełny ciąg rzuca monetą podejście , co czyni program bardzo duża. Sam odczyt pojedynczych liczb całkowitych jeden po drugim sprawiłby, że program byłby mniejszy - może około 22 bajtów lub mniej więcej - ale również bardzo niewygodny w użyciu.

Przykłady:

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!

Moje repozytorium GitHub wosku pszczelego.

Moje przykłady wosku pszczelego na temat kodu Rosetta.