Sie haben eine Münze, die 0oder produziert 1. Sie vermuten jedoch, dass die Münze voreingenommen ist , was bedeutet, dass die Wahrscheinlichkeit 0(oder 1) nicht unbedingt 1/2 beträgt.

Ein bekanntes Verfahren zur "Umwandlung" einer voreingenommenen Münze in eine faire Münze (dh zur Erzielung gleichwahrscheinlicher Ergebnisse), wie von Neumann vorgeschlagen, lautet wie folgt. Produziere (nicht überlappende) Blöcke mit zwei Münzwürfen, bis sich die beiden Werte eines Blocks unterscheiden. und gebe den ersten Wert in diesem Block aus (der zweite Wert würde auch reichen, aber für die Zwecke dieser Herausforderung wählen wir den ersten). Intuitiv 1kann eher als 0, aber 01und 10wird gleich wahrscheinlich sein.

Zum Beispiel 1110...würde die Eingabe den ersten Block verwerfen und dann einen 1aus dem zweiten Block erzeugen , ...

Dieses Verfahren ist teuer , da mehrere Münzwürfe verbraucht werden, um ein einziges Ergebnis zu erzielen.

Die Herausforderung

Nehmen Sie eine endliche Folge von Nullen und Einsen, die Würfe der ursprünglichen Münze darstellen, und erzeugen Sie die maximale Anzahl von Ergebnissen gemäß dem oben beschriebenen Verfahren, bis die gesamte Eingabe verbraucht ist.

Der letzte Block kann unvollständig sein, wenn die Anzahl der Eingabewerte ungerade ist. Beispielsweise 11111würde die Eingabesequenz kein Ergebnis liefern (die ersten beiden Blöcke haben gleiche Werte und der dritte Block ist unvollständig).

Regeln

Die Eingabe kann eine beliebige nicht negative Anzahl von Werten haben, nicht unbedingt positive oder gerade.

Das Eingabeformat kann sein:

• eine Anordnung von Nullen und Einsen;
• eine Folge von Nullen und Einsen mit einem optionalen Trennzeichen.

Ausgabeformat kann sein:

• eine Folge von Nullen und Einsen mit oder ohne Trennzeichen;
• eine Anordnung von Nullen und Einsen;
• Zeichenfolgen, die eine einzelne Null oder Eins enthalten, durch Zeilenumbrüche getrennt;
• Jedes ähnliche, vernünftige Format, das zu Ihrer Sprache passt.

Code Golf. Wenigste Bytes gewinnt.

Testfälle

Eingabe und Ausgabe werden hier als Zeichenfolgen angenommen.

Input         -->  Output

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

Gelee, 6 Bytes

s2Q€Ṗ€

Probieren Sie es online!

Wie es funktioniert

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 bis 14 Bytes

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

Probieren Sie es online!

Erläuterung

Das ist ziemlich einfach. Der Code definiert eine einzelne Regex-Ersetzung, die alle (nicht überlappenden) Übereinstimmungen (.)\1|(.)?.mit der zweiten erfassten Gruppe ersetzt. Dies kombiniert drei verschiedene Fälle zu einem:

(.)\1 --> <empty>

Wenn zwei wiederholte Ziffern gleich sind, entfernen wir sie aus der Zeichenfolge (da Gruppe 2 nicht verwendet wird).

(.).  --> $2

Wenn wir ansonsten zwei Zeichen zuordnen können, entfernen Sie das zweite, indem Sie beide durch das erste ersetzen. Wenn dies nicht der Fall ist, ?wird die Gruppe weggelassen:

.     --> <empty>

Dies geschieht nur, wenn ein nicht gepaartes abschließendes Zeichen vorhanden ist, das ebenfalls entfernt wird.

Labyrinth , 21 12 Bytes

"(. :
""*$,@

Ein seltenes Beispiel für ein kompaktes Labyrinth-Programm, das auch keine No-Ops enthält. Die |in der vorherigen Version war völlig unnötig und das Entfernen hat die Größe des Programms massiv reduziert. Tatsächlich schlägt Lab die Netzhaut!

Probieren Sie es online!

Das "Feld unten links kann auch ein Leerzeichen sein, aber es vereinfacht die Erklärung erheblich, wenn es dort steht.

Erläuterung

Das hier ist ein bisschen kniffliger, es wird von Bildern begleitet. Aber zuerst eine kurze Einführung:

• Labyrinth ist eine stapelbasierte 2D-Sprache. Der Speicher besteht aus einem Hauptstapel und einem Hilfsstapel.
• Die Stapel des Labyrinths sind bodenlos und mit Nullen gefüllt, sodass das Ausführen von Operationen mit einem leeren Stapel kein Fehler ist.
• An jeder Kreuzung, an der zwei oder mehr Pfade für den Befehlszeiger vorhanden sind, wird die Oberseite des Hauptstapels überprüft, um herauszufinden, wohin als Nächstes zu gehen ist. Negativ ist links abbiegen, Null ist geradeaus und positiv ist rechts abbiegen. Wenn eine Wende fehlschlägt, versucht der Zeiger, sich in die andere Richtung zu drehen.

Installieren

Das Programm startet oben links ", was ein No-Op ist. Dann führen wir durch:

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

Dies belässt den Stapel mit einer einzelnen 0, die für die Zwecke von Labyrinth so gut wie leer ist.

Eingabe lesen und beenden

,Liest ein Zeichen von der Eingabe und gibt 48 oder 49 für 0bzw. 1und -1 für EOF zurück. Da dies ungleich Null ist, drehen wir uns in die Richtung :, die die Oberseite des Stapels dupliziert.

Das :ist in einer Sackgasse, also drehen wir uns um und führen ,noch einmal aus. Nun , wenn die letzte Eingabe EOF ist, dann biegen wir links ab und enden mit @, sonst rechts wenden wir uns, mit dem Stapel, die wie [a a b](wo a, bsind die beiden Zeichen).

Interpretation des Münzwurfs

Wenn wir nicht abgebrochen haben, besteht unser nächster Schritt darin, $(bitweises xor) erneut auszuführen . Dies ergibt 0, wenn die Eingabezeichen gleich waren, andernfalls 1. Wir multiplizieren dann amit diesem Ergebnis und geben entweder 0 oder a. Da sich das *an einer Kreuzung befindet, bestimmt dieser obere Stapelwert, was als Nächstes geschieht.

Im Fall 0 gehen wir geradeaus und führen drei "No-Ops aus, bevor wir eine (Dekrementierung durchführen. Wie beim Setup werden wir gedreht und ausgeführt "*$, sodass wir bereit sind, weitere Zeichen zu lesen.

Andernfalls abiegen wir in diesem Fall an der Kreuzung rechts ab, da dies apositiv ist (48 oder 49). .gibt das Zeichen aus, lässt den Stapel leer und (dekrementiert den oberen Bereich des Stapels, wobei eine 0 auf -1 gesetzt wird. Dies bringt uns wieder dazu, nach links abzubiegen, "*$wie im Setup ausgeführt, und bereit zu sein, weitere Eingaben zu lesen.

CJam, 10 8 Bytes

l2/{)-}%

Teste es hier.

Erläuterung

Dies ist eine sehr einfache Lösung: Entfernen Sie in jedem Paar alle Instanzen des letzten Zeichens. Wiederholte Ziffern und nicht gepaarte nachfolgende Ziffern werden entfernt, ebenso wie die zweite Ziffer in einem ungleichen Ziffernpaar:

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

Dies lässt nur die Ziffern, die wir suchen. So berechnet der Code das:

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

Wenn die Liste am Ende des Programms automatisch ausgedruckt wird, werden die leeren Zeichenfolgen einfach weggelassen.

Perl, 19 18 17 Bytes

@Martin Büttner Retina-Lösung inspirierte zu einem Gewinn von 2 Byte

Beinhaltet +1 für -p

Führen Sie mit der Eingabe auf STDIN, z perl -p fair.pl <<< 11000110

fair.pl:

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

Hier ist nicht viel zu erklären, da es sich um eine (indirekte) Übersetzung der Spezifikation handelt:

• (.)\1 Wenn die ersten beiden Ziffern identisch sind, lassen Sie sie fallen
• .\K. Ansonsten sind die ersten beiden Ziffern unterschiedlich. Behalte ( \K) den ersten
• .?\K.Mit der Ausnahme, dass das erste .optional ist. Dies ermöglicht eine einzelne Übereinstimmung am Ende der Zeichenfolge, die dann verworfen wird, da der gehaltene Teil leer ist

Mathematica, 36 38 Bytes

-2 nach dem Diebstahl von @ LegionMammal978s Funktion zur Bestimmung, ob eine Liste mit 2 Elementen den Wert {0,1} oder {1,0} hat

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

Es wird erwartet, dass das Argument eine Liste von ganzen Zahlen ist.

Hexagony , 23 21 Bytes

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

Entfaltet:

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

Das wird mit einem Fehler beendet aber die Fehlermeldung geht an STDERR.

Probieren Sie es online!

Gemessen an der Anzahl der Spiegel ist es vielleicht gerade noch möglich, sie in Seitenlänge 3 einzubauen, aber ich hatte bisher kein Glück.

Erläuterung

Hier ist das übliche Diagramm, das mit Timwis HexagonyColorer erstellt wurde :

Das Programm verwendet hier nur drei Speicherflanken mit den Bezeichnungen A , B und C (Diagramm mit freundlicher Genehmigung von Timwi's EsotericIDE ):

Die Ausführung beginnt auf blauem Weg. Dies /sind nur Spiegel, die den Anweisungszeiger (IP) umleiten. Der eigentliche Code lautet:

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

Das ,setzt die Kante auf -1anstelle des Zeichencodes, wenn wir EOF gedrückt haben. Da wir beide Eingänge inkrementieren, ändert sich nichts daran, ob sie gleich sind oder nicht, aber es wird EOF 0.

Wir verwenden modulo, um die Gleichheit zu überprüfen, da es entweder 1oder 49(positiv) für ungleiche Zeichen und 0für gleiche Zeichen ist. Es dient auch als Programmende, da 0die versuchte Division durch Null einen Fehler verursacht , wenn es sich um die von EOF handelt.

Das <unterscheidet nun Nullen von positiven Ergebnissen. Das Einfache zuerst: Wenn die Zeichen gleich sind, nimmt die IP den roten Pfad. _ist ein Spiegel, \ist auch ein Spiegel, wird aber ignoriert und >lenkt die IP so um, dass sie sich um die Kanten wickelt und wieder von oben beginnt. Bei dieser Iteration werden jedoch die Rollen von A , B und C zyklisch vertauscht ( C übernimmt jetzt die Rolle von A usw.).

Wenn die Zeichen unterschiedlich sind, wird stattdessen der grüne Pfad verwendet. Das hier ist etwas chaotischer. Es springt zuerst über ein No-Op mit $, läuft dann bis zum /linken Rand, durchläuft dann die vorletzte Zeile von rechts nach links und gibt schließlich den interessanten Teil des Quellcodes am erneut ein {. Es gibt ein im Wesentlichen lineares Stück Code, das ich in einer Sekunde erklären werde, bevor $die IP über das springt >, um die beiden Pfade wieder zusammenzuführen.

Hier ist der lineare Code:

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

Beachten Sie, dass in diesem Fall die Rollen der Kanten für die nächste Iteration ebenfalls zyklisch vertauscht werden, wobei B jedoch die Rolle von A usw. übernimmt .

Haskell, 71 44 29 Bytes

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

Extremes Golfen von Nimi .

> <> , 11 Bytes

i:i:0(?;-?o

> <> eignet sich ziemlich gut zum Lesen von Char-at-A-Time-Herausforderungen wie folgt :) Probieren Sie es online aus!

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)

Dies alles geschieht in einer Schleife, da der Anweisungszeiger am Ende einer Zeile herumläuft.

Python, 42 Bytes

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

Spaß mit Rekursion und bitweisem xor. Nimmt eine Liste von 1 und 0 als Eingabe.

JavaScript (ES6), 33 Byte

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

Wie es funktioniert

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.

Vorspiel , 12 Bytes

11(-(#!)?^?)

Dies setzt einen Interpreter voraus, der Zeichen liest und druckt. Sie können es auch online ausprobieren. Dass aber die Dolmetscher druckt ganze Zahlen, so dass für jeden 0werden Sie erhalten 48und für jeden 1werden Sie erhalten 49statt (und ein Zeilenvorschub).

Erläuterung

Es ist sehr selten, dass Sie in Prelude ein nicht-triviales Programm in einer einzelnen Zeile schreiben können (da Prelude mehr als eine Zeile benötigt, um vollständig zu sein).

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 Bytes

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

Byte für die -nFlagge hinzugefügt .

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

Prüfung:

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

1



1101001
0
1011101010
1111

Danke an @TonHospel für 6 Bytes!

Befunge 93 , 16 Bytes

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

Ein Einzeiler für Kompaktheit. Getestet mit diesem Online-Interpreter .

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

Der letzte Teil nutzt die Tatsache, dass das Poppen von einem leeren Befunge-93-Stapel 0 ergibt .

Wenn a != bwir durchführen

>                      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

Andernfalls a == bführen wir Folgendes aus:

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

jkPM{Mcz2

Algorithmus schamlos aus Dennis 'Gelee-Antwort gestohlen .

       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 Bytes

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

Probieren Sie es online aus

Vielen Dank an Dennis und Vaultah für den Hinweis auf Dinge, die ich verpasst habe

Mathematica, 41 39 Bytes

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

Weniger kompliziert und kürzer als die andere Antwort. Die Box ist ein transponierter Charakter.

JavaScript (ES6), 33 Byte

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

Langweiliger Hafen der Retina Antwort.

sed, 34 33 bytes

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

Prüfung:

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

1



1101001
0
1011101010
1111

Labyrinth , 31 Bytes

Nicht so kurz und ordentlich wie die Sp3000-Lösung, aber ich dachte, ich würde das trotzdem als einen anderen Ansatz posten:

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

Erläuterung

Die erste Schleife ist einfach

""
,,

das liest in zwei Zeichen gleichzeitig (das "sind No-Ops). Nach EOF ,wird zurückgegeben -1, es wird jedoch nur bei jedem zweiten Zeichen auf EOF geprüft. Das bedeutet in jedem Fall, dass der obere Teil des Stapels dann ist -1und der Wert darunter entweder ein -1oder ein Zeichencode ist, den wir nicht interessieren, da es sich um einen ungepaarten Münzwurf handelt.

Dann )*wandelt man das -1und den Wert darunter in einen einzigen Wert um, 0den wir a) benötigen, um diese beiden Werte zu beseitigen, und b) um die nächste Schleife korrekt einzugeben. Diese nächste Schleife ist einfach

"}
""

Dadurch werden alle Werte auf den Zusatzstapel verschoben. Dies ist notwendig, da wir die zuerst gelesenen Paare verarbeiten möchten. Nun die letzte Schleife:

:{"
{ $;
)";.

Das )erhöht nur einen Dummy-Wert, um sicherzustellen, dass er positiv ist und der Befehlszeiger nach Norden zeigt. {Zieht über die erste Ziffer des nächsten Paares und :dupliziert es. Nun, wenn wir mit der Verarbeitung fertig sind, wird dies 0von der Unterseite des Hilfsstapels gewesen sein. Ansonsten ist es entweder 48oder 49. Im Falle einer Null verlassen wir die Schleife und enden an @, ansonsten dreht sich die IP nach Osten.

{zieht über die andere Ziffer des aktuellen Paares. $nimmt die XOR zwischen ihnen. Wenn dies 0 ist, dh die beiden gleich sind, bewegt sich die IP einfach weiter nach Süden, ;wirft die Null ab und die IP dreht sich nach Westen in die nächste Iteration. Wenn das XOR war 1, dh sie waren unterschiedlich, dreht sich die IP nach Westen, verwirft das 1mit ;und druckt die erste Ziffer mit ..

MATL , 11 9 8 Bytes

`-?6MD]T

Eingabe und Ausgabe sind durch Zeilenumbrüche getrennte Zahlen. Beendet mit einem Fehler (standardmäßig zulässig), wenn alle Eingaben verbraucht wurden.

Probieren Sie es 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

Alter Ansatz, 11 Bytes

2YCd9L)Xz0<

Die Eingabe ist eine Zeichenfolge. Die Ausgabe erfolgt durch Zeilenumbrüche getrennte Zahlen.

Probieren Sie es 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 Bytes

Dies trennt l[0], l[1]und l[2..{end}]wie a, bund c. Dann wird eine Zeichenfolge mit aif a!=boder ''else erstellt und f[c]wenn c[0]vorhanden oder ''anderweitig.

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 Bytes

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

Im Vergleich zu Java ist dies sehr kompakt, ich habe jedoch Angst vor dem Brainfuck-Golfer-Beantworter. Und Sie können gerne erwähnen, ob es einen Fehler gibt. Angenommen, EOF ist 0, die Eingabe enthält keine ungültigen Eingaben, die Zelle ist anfangs Null und der Zellenwertebereich ist endlich und zyklisch. Es liegt keine andere Annahme vor.

Erläuterung:

Memory Cell Map

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

Anweisung

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

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

Anonyme Funktion, die Listen mit Nullen und Einsen ein- und ausgibt.

Pyth, 10 Bytes

hMf!qFTcz2

Testsuite

C 66 Bytes

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

Vorausgesetzt sizeof(int) == sizeof(char *)

"clevere" Lösung - 84 81 Bytes

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

Funktioniert auf Little-Endian-Rechnern mit short2 Bytes. Die Eingabe wird als Argument übergeben. Das Programm durchläuft Zeichenpaare und gibt 0 für 0x3130 und 1 für 0x3031 aus. Auf Big-Endian wird das Ergebnis umgekehrt (ersetzen 48|c&1mit , 49^c&1dies zu beheben).

C 57 Bytes

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

Wir kopieren versuchsweise ein Zeichen von der Eingabe pin das Ergebnis r, bewegen den rZeiger jedoch nur, wenn er vom nächsten Zeichen abweicht. Wenn nicht, werden wir es beim nächsten nicht passenden Paar oder NULam Ende mit überschreiben .

Testprogramm:

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

Testausgang:

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

Befunge-93 , 40 Bytes

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

Sie können es hier ausprobieren . Fügen Sie Code in das Feld unter der Schaltfläche "Anzeigen" ein, drücken Sie "Anzeigen", definieren Sie die Eingabe, drücken Sie "Ausführen". Verwenden Sie den "Schritt" -Button, um zu sehen, wie das Programm funktioniert.

DOS / Windows Batch, 201 162 Bytes

@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

Die Eingabe ist beispielsweise eine durch Leerzeichen getrennte Zeichenfolge 1 0 0 1 1. Beginnen Sie mit cmd, andernfalls wird der Bildschirm sofort geschlossen

Bienenwachs ,45 35 Bytes

Ich könnte es um 10 Bytes reduzieren - nicht schlecht.

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

Ich habe eine ganze Reihe von Münzwürfen gelesen , was das Programm ziemlich umfangreich macht. Nur einzelne Ganzzahlen nacheinander zu lesen, würde das Programm kleiner machen - vielleicht um 22 Bytes oder so -, aber auch sehr unpraktisch in der Verwendung.

Beispiele:

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!

Mein Bienenwachs-GitHub-Repository.

Meine Bienenwachsbeispiele auf Rosetta Code.