Hai una moneta che produce 0o 1. Ma si sospetta che la moneta può essere prevenuto , il che significa che la probabilità di 0(o 1) non è necessariamente 1/2.

Una procedura ben nota per "trasformare" una moneta distorta in una moneta giusta (cioè per ottenere risultati altrettanto probabili), come proposta da von Neumann, è la seguente. Produci blocchi (non sovrapposti) di due lanci di monete fino a quando i due valori di un blocco differiscono; e genera il primo valore in quel blocco (lo farebbe anche il secondo valore, ma ai fini di questa sfida scegliamo il primo). Intuitivamente, 1potrebbe essere più probabile di 0, ma 01e 10sarà ugualmente probabile.

Ad esempio, l'ingresso 1110...eliminerebbe il primo blocco, quindi produrrebbe un 1dal secondo blocco, ...

Questa procedura è costosa , poiché vengono utilizzati diversi lanci di monete per generare un singolo risultato.

La sfida

Prendi una sequenza finita di zeri e uno, che rappresentano i lanci della moneta originale, e produci il numero massimo di risultati secondo la procedura sopra, fino a quando tutto l'input è consumato.

L'ultimo blocco può essere incompleto, se il numero di valori di input è dispari. Ad esempio, la sequenza di input 11111non produrrebbe alcun risultato (i primi due blocchi hanno valori uguali e il terzo blocco è incompleto).

Regole

L'input può avere qualsiasi numero non negativo di valori, non necessariamente positivo o pari.

Il formato di input può essere:

• una matrice di zeri e uno;
• una stringa di zeri e quelli con un separatore opzionale.

Il formato di output può essere:

• una stringa di zeri e uno, con o senza separatori;
• una matrice di zeri e uno;
• stringhe contenenti un singolo zero o uno, separate da newline;
• qualsiasi formato simile e ragionevole adatto alla tua lingua.

Codice golf. Vince il minor numero di byte.

Casi test

Si presume che input e output siano stringhe.

Input         -->  Output

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

Gelatina, 6 byte

s2Q€Ṗ€

Provalo online!

Come funziona

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

Provalo online!

Spiegazione

Questo è abbastanza semplice. Il codice definisce una singola sostituzione regex sostituendo tutte le corrispondenze (non sovrapposte) (.)\1|(.)?.con qualsiasi cosa il secondo gruppo acquisito. Questo combina tre casi diversi in uno:

(.)\1 --> <empty>

Se due cifre ripetute sono uguali, le rimuoviamo dalla stringa (poiché il gruppo 2 non è utilizzato).

(.).  --> $2

Altrimenti, se possiamo abbinare due personaggi, rimuovi il secondo, sostituendo entrambi con il primo. In caso contrario ?, ometterà il gruppo:

.     --> <empty>

Questo succede solo se c'è un personaggio finale non accoppiato, che viene anche rimosso.

Labyrinth , 21 12 byte

"(. :
""*$,@

Un raro esempio di un programma Labyrinth compatto che non ha operazioni. La |versione precedente era completamente superflua e rimuoverla riduceva enormemente le dimensioni del programma. In effetti, Lab sta battendo Retina!

Provalo online!

L'angolo in basso a sinistra "può anche essere uno spazio, ma averlo lì semplifica notevolmente la spiegazione.

Spiegazione

Questo è un po 'più complicato, quindi è accompagnato da immagini. Ma prima, un rapido primer:

• Labyrinth è un linguaggio 2D basato su stack. La memoria è composta da uno stack principale e uno stack ausiliario.
• Le pile di Labyrinth sono senza fondo e piene di zeri, quindi eseguire operazioni su una pila vuota non è un errore.
• Ad ogni incrocio, dove ci sono due o più percorsi per il puntatore dell'istruzione, la parte superiore dello stack principale viene controllata per capire dove andare dopo. Il negativo è girare a sinistra, zero è dritto e il positivo è girare a destra. Se una svolta non riesce, il puntatore tenta di girare nella direzione opposta.

Impostare

Il programma inizia in alto a sinistra ", che è una no-op. Quindi eseguiamo:

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

Questo lascia lo stack con un singolo 0 su di esso, che è buono come vuoto ai fini di Labyrinth.

Lettura input e terminazione

,legge un carattere dall'input, restituendo 48 o 49 per 0o 1rispettivamente e -1 su EOF. Poiché questo è diverso da zero, in entrambi i casi ci trasformiamo in :, che duplica la parte superiore dello stack.

Il :è in un vicolo cieco, quindi ci voltiamo e eseguiamo ,una volta di più. Ora se l'ultimo input è stato EOF, allora giriamo a sinistra e terminiamo con @, altrimenti giriamo a destra, con lo stack che assomiglia [a a b](dove a, bsono i due caratteri).

Interpretazione del lancio della moneta

Se non abbiamo terminato, la nostra prossima mossa è eseguire $nuovamente (bit per bit). Questo produce 0 se i caratteri di input erano uguali, 1 altrimenti. Quindi moltiplichiamo aper questo risultato, dando 0 o a. Dato che si *trova a un incrocio, questo valore di stack superiore determina cosa succede dopo.

Nel caso 0, andiamo dritto ed eseguiamo tre "no-op, prima di eseguire un (decremento. Come l'installazione, questo ci fa girare ed eseguire "*$, lasciandoci pronti a leggere più caratteri.

Altrimenti, nel acaso, svoltiamo a destra all'incrocio poiché aè positivo (48 o 49). .genera il carattere, lasciando vuoto lo stack e (diminuisce la parte superiore dello stack, trasformando uno 0 in -1. Ancora una volta, questo ci fa girare a sinistra, eseguendo "*$come nell'impostazione, lasciandoci anche pronti a leggere più input.

CJam, 10 8 byte

l2/{)-}%

Provalo qui.

Spiegazione

Questa è una soluzione molto semplice: in ogni coppia, rimuovi tutte le istanze dell'ultimo carattere. Le cifre ripetute e le cifre finali non accoppiate verranno rimosse, così come la seconda cifra in qualsiasi coppia di cifre disuguali:

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

Questo lascia solo le cifre che stiamo cercando. Ecco come il codice calcola questo:

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

Quando l'elenco viene stampato automaticamente alla fine del programma, le stringhe vuote vengono semplicemente omesse.

Perl, 19 18 17 byte

La soluzione @Martin Büttner Retina ha ispirato un guadagno di 2 byte

Include +1 per -p

Esegui con l'ingresso su STDIN, ad es perl -p fair.pl <<< 11000110

fair.pl:

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

Non c'è molto da spiegare qui poiché si tratta di una traduzione (indiretta) della specifica:

• (.)\1 Se le prime 2 cifre sono uguali, rilasciarle
• .\K. Altrimenti le prime due cifre sono diverse. Keep ( \K) il primo
• .?\K.Tranne che il primo .è facoltativo. Ciò consente una singola corrispondenza alla fine della stringa che viene quindi scartata poiché la parte mantenuta è vuota

Mathematica, 36 38 byte

-2 dopo aver rubato la funzione di @ LegionMammal978 per determinare se un elenco di 2 elementi è {0,1} o {1,0}

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

L'argomento dovrebbe essere un elenco di numeri interi.

Esagonia , 23 21 byte

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

non piegato:

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

Questo termina con un errore, ma il messaggio di errore va a STDERR.

Provalo online!

A giudicare dal numero di specchi potrebbe essere quasi possibile inserirlo in 3 di lunghezza laterale ma finora non ho avuto fortuna.

Spiegazione

Ecco il solito diagramma, generato con HexagonyColorer di Timwi :

Il programma utilizza solo tre fronti di memoria, etichettati A , B e C qui (diagramma per gentile concessione dell'EsotericIDE di Timwi ):

L'esecuzione inizia sul percorso blu. L' /sono solo specchi che reindirizzano il puntatore all'istruzione (IP), il codice attuale è:

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

Il ,imposterà il bordo al -1posto del codice di carattere, se abbiamo colpito EOF. Dal momento che stiamo incrementando entrambi gli input che non cambiano se sono uguali o meno, ma trasforma EOF in 0.

Usiamo il modulo per verificare l'uguaglianza, perché è uno 1o 49(positivo) per caratteri disuguali e 0caratteri uguali. Serve anche come fine del programma, perché quando abbiamo il 0da EOF, la tentata divisione per zero causerà un errore.

Ora <distingue gli zero dai risultati positivi. Quello semplice prima: se i caratteri sono uguali, l'IP prende il percorso rosso. _è uno specchio, \è anche uno specchio ma viene ignorato e >devia l'IP in modo tale da avvolgere i bordi e ricominciare da capo. Tuttavia, su questa iterazione, i ruoli di A , B e C vengono scambiati ciclicamente ( C ora assume il ruolo di A e così via).

Se i caratteri sono diversi, viene invece preso il percorso verde. Questo è un po 'più disordinato. Prima salta su una no-op con $, quindi si avvolge /sul bordo sinistro, quindi attraversa la penultima riga da destra a sinistra e infine reinserisce la parte interessante del codice sorgente su {. C'è un bit di codice essenzialmente lineare, che spiegherò tra un secondo, prima $che l'IP salti sopra >per unire nuovamente i due percorsi.

Ecco quel pezzo di codice lineare:

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

Si noti che in questo caso, anche i ruoli dei bordi per la successiva iterazione vengono scambiati ciclicamente, ma con B che assume il ruolo di A e così via.

Haskell, 71 44 29 byte

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

Golf estremo di nimi .

> <> , 11 byte

i:i:0(?;-?o

> <> è abbastanza adatto per le sfide di questo tipo come questo :) Provalo 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)

Tutto ciò accade in un ciclo poiché il puntatore dell'istruzione si avvolge quando raggiunge la fine di una riga.

Python, 42 byte

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

Divertimento con ricorsione e bit per bit. Accetta un elenco di 1 e 0 come input.

JavaScript (ES6), 33 byte

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

Come funziona

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.

Preludio , 12 byte

11(-(#!)?^?)

Questo presuppone un interprete che legge e stampa caratteri. Puoi provarlo online. Ma quell'interprete stampa numeri interi, quindi per ognuno 0otterrai 48e per ciascuno1 otterrai 49invece (e un avanzamento di riga).

Spiegazione

È molto raro che tu possa scrivere un programma non banale su una sola riga in Prelude (perché Prelude ha bisogno di più di una riga per essere 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 byte

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

Byte aggiunto per la -nbandiera.

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

Grazie a @TonHospel per 6 byte!

Befunge 93 , 16 byte

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

Una fodera per compattezza. Testato usando questo interprete online .

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

L'ultima parte sfrutta il fatto che spuntare da uno stack Befunge-93 vuoto produce 0 .

Se a != b, ci esibiamo

>                      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

Altrimenti, se a == beseguiamo:

>                      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

Algoritmo rubato senza vergogna dalla risposta della gelatina di Dennis .

       z    input
      c 2   chunks of 2
    {M      dedup each chunk
  PM        all-but-last element of each chunk
jk          join on empty string; can't use `s' because that gives `0' for []

Python 2, 48 byte

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

Provalo online

Grazie a Dennis e Vaultah per aver sottolineato le cose che mi sono perso

Mathematica, 41 39 byte

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

Meno complicato e più breve dell'altra risposta. La casella è un carattere di trasposizione.

JavaScript (ES6), 33 byte

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

Porto noioso della risposta Retina.

sed, 34 33 byte

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

Labirinto , 31 byte

Non così breve e pulito come la soluzione Sp3000, ma ho pensato di pubblicarlo comunque come un approccio diverso:

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

Spiegazione

Il primo ciclo è semplicemente

""
,,

che legge due caratteri alla volta ( "non si tratta di operazioni). Dopo EOF, ,tornerà -1, ma controlla solo EOF ad ogni secondo carattere. Ciò significa che in ogni caso la parte superiore dello stack sarà quindi -1e il valore sottostante è entrambi-1 o qualche codice di carattere che non ci interessa, perché è un lancio di monete spaiato.

Quindi )*trasforma il -1e il valore sottostante in un singolo di 0cui abbiamo bisogno a) per sbarazzarci di quei due valori eb) per inserire correttamente il ciclo successivo. Quel ciclo successivo è semplicemente

"}
""

Il che sposta tutti i valori sullo stack ausiliario. Questo è necessario perché vogliamo iniziare a elaborare le coppie che leggiamo per prime. Ora il ciclo finale:

:{"
{ $;
)";.

Il )valore incrementa solo un valore fittizio per assicurarsi che sia positivo e che il puntatore dell'istruzione giri a nord. {passa sopra la prima cifra della coppia successiva e la :duplica. Ora, quando avremo terminato l'elaborazione, questo sarà stato 0dal fondo dello stack ausiliario. Altrimenti è o 48o 49. In caso di zero, usciamo dal loop e terminiamo @, altrimenti l'IP gira verso est.

{passa sopra l'altra cifra della coppia corrente. $prende l'XOR tra di loro. Se questo è 0, ovvero i due sono uguali, l'IP continua a spostarsi verso sud, ;scarta lo zero e l'IP si trasforma in ovest nella successiva iterazione. Se lo XOR era 1, cioè erano diversi, l'IP gira a ovest, scarta il 1con ;e stampa la prima cifra con ..

MATL , 11 9 8 byte

`-?6MD]T

Input e output sono numeri separati da newline. Termina con un errore (consentito per impostazione predefinita) quando tutti gli input sono stati consumati.

Provalo 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

Vecchio approccio, 11 byte

2YCd9L)Xz0<

L'input è una stringa. L'output è costituito da numeri separati da newline.

Provalo 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

Rubino, 46 ​​byte

Questo separa l[0], l[1]e l[2..{end}]come ae be c. Quindi crea una stringa con aif a!=bo ''altrimenti e f[c]se c[0]esiste o ''meno.

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 byte

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

Rispetto a Java, questo è molto compatto, tuttavia, ho paura del risponditore brainfuck-golfista. E sentiti libero di dire se c'è un bug. Supponendo che EOF sia 0, l'input non contiene input non validi, la cella è inizialmente zero e l'intervallo di valori della cella è finito e ciclico. Nessun altro presupposto è presente.

Spiegazione:

Mappa delle celle di memoria

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

istruzione

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

Funzione anonima che inserisce e genera elenchi di zeri e di quelli.

Pyth, 10 byte

hMf!qFTcz2

Suite di test

C, 66 byte

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

assumendo sizeof(int) == sizeof(char *)

soluzione "intelligente" - 84 81 byte

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

Funziona su una macchina little-endian supponendo che shortsia di 2 byte. L'input viene passato come argomento. Il programma scorre su coppie di caratteri e stampa 0 per 0x3130 e 1 per 0x3031. Su big-endian il risultato sarà invertito (sostituirlo 48|c&1con 49^c&1per risolvere questo problema).

C, 57 byte

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

Copiamo provvisoriamente un carattere dall'input pal risultato r, ma avanziamo il rpuntatore solo se differisce dal carattere successivo. In caso contrario, lo sovrascriveremo alla prossima coppia senza pari, o con NULalla fine.

Programma di test:

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

Uscita di prova:

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

Puoi provarlo qui . Incolla il codice nello spazio sotto il pulsante "mostra", premi "mostra", definisci input, premi "esegui". Usiamo il pulsante "step" per vedere come funziona il programma.

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

L'input è una stringa separata da spazio, ad esempio 1 0 0 1 1. Inizia da cmd, altrimenti lo schermo esce immediatamente

cera d'api ,45 35 byte

Potrei giocare a golf di 10 byte, non male.

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

Ho preso la lettura di una serie completa di lanci di monete , il che rende il programma piuttosto ampio. La sola lettura di singoli numeri uno per uno renderebbe il programma più piccolo - forse circa 22 byte circa - ma sarebbe anche molto scomodo da usare.

Esempi:

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!

Il mio repository GitHub di cera d'api.

I miei esempi di cera d'api sul codice Rosetta.