Tienes una moneda que produce 0o 1. Pero sospecha que la moneda puede estar sesgada , lo que significa que la probabilidad de 0(o 1) no es necesariamente 1/2.

Un procedimiento bien conocido para "transformar" una moneda sesgada en una moneda justa (es decir, para obtener resultados igualmente probables), como lo propone von Neumann, es el siguiente. Produzca bloques (no superpuestos) de dos lanzamientos de monedas hasta que los dos valores de un bloque difieran; y generar el primer valor en ese bloque (el segundo valor también funcionaría, pero para los propósitos de este desafío, elegimos el primero). Intuitivamente, 1puede ser más probable que 0, sin embargo 01, y 10será igualmente probable.

Por ejemplo, la entrada 1110...descartaría el primer bloque, luego produciría un 1del segundo bloque, ...

Este procedimiento es costoso , porque se consumen varios lanzamientos de monedas para generar un solo resultado.

El reto

Tome una secuencia finita de ceros y unos, que representan lanzamientos de la moneda original, y produzca el número máximo de resultados de acuerdo con el procedimiento anterior, hasta que se consuma toda la entrada.

El último bloque puede estar incompleto, si el número de valores de entrada es impar. Por ejemplo, la secuencia de entrada 11111no produciría ningún resultado (los dos primeros bloques tienen valores iguales y el tercer bloque está incompleto).

Reglas

La entrada puede tener cualquier número de valores no negativos, no necesariamente positivos o pares.

El formato de entrada puede ser:

• una serie de ceros y unos;
• Una cadena de ceros y unos con un separador opcional.

El formato de salida puede ser:

• una cadena de ceros y unos, con o sin separadores;
• una serie de ceros y unos;
• cadenas que contienen un solo cero o uno, separados por nuevas líneas;
• cualquier formato similar y razonable que se adapte a su idioma.

Código de golf. Pocos bytes ganan.

Casos de prueba

Aquí se supone que la entrada y la salida son cadenas.

Input         -->  Output

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

Jalea, 6 bytes

s2Q€Ṗ€

Pruébalo en línea!

Cómo funciona

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 bytes

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

Pruébalo en línea!

Explicación

Esto es bastante simple. El código define una única sustitución de expresiones regulares que reemplaza todas las coincidencias (no superpuestas) de (.)\1|(.)?.lo que sea que haya capturado el segundo grupo. Esto combina tres casos diferentes en uno:

(.)\1 --> <empty>

Si dos dígitos repetidos son iguales, los eliminamos de la cadena (porque el grupo 2 no está en uso).

(.).  --> $2

De lo contrario, si podemos unir dos caracteres, elimine el segundo, reemplazándolos por el primero. Si ese no es el caso ?, omitirá el grupo:

.     --> <empty>

Esto solo sucede si hay un carácter final no emparejado, que también se elimina.

Laberinto , 21 12 bytes

"(. :
""*$,@

Un raro ejemplo de un programa compacto de Labyrinth que tampoco tiene no-ops. La |versión anterior era completamente innecesaria, y su eliminación redujo enormemente el tamaño del programa. De hecho, ¡Lab está superando a Retina!

Pruébalo en línea!

La esquina inferior izquierda "también puede ser un espacio, pero tenerla allí simplifica enormemente la explicación.

Explicación

Este es un poco más complicado, por lo que va acompañado de imágenes. Pero primero, una introducción rápida:

• Labyrinth es un lenguaje 2D basado en pila. La memoria consta de una pila principal y una pila auxiliar.
• Las pilas de Labyrinth no tienen fondo y están llenas de ceros, por lo que realizar operaciones en una pila vacía no es un error.
• En cada cruce, donde hay dos o más rutas para que vaya el puntero de instrucciones, se comprueba la parte superior de la pila principal para averiguar a dónde ir después. Negativo es girar a la izquierda, cero es recto y positivo es girar a la derecha. Si falla un giro, el puntero intenta girar en la otra dirección.

Preparar

El programa comienza en la esquina superior izquierda ", que no funciona. Luego realizamos:

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

Esto deja a la pila con un solo 0, que es tan bueno como vacío para los propósitos de Labyrinth.

Lectura de entrada y terminación

,lee un carácter de entrada, devolviendo 48 o 49 para 0o 1respectivamente, y -1 en EOF. Como esto no es cero, de cualquier manera nos convertimos en :, que duplica la parte superior de la pila.

El :está en un callejón sin salida, por lo que damos la vuelta y ejecutamos ,una vez más. Ahora bien, si la última entrada fue EOF, a continuación, giramos a la izquierda y terminar con el @, de lo giramos a la derecha, con la pila que parece [a a b](donde a, bson los dos caracteres).

Interpretando el lanzamiento de la moneda

Si no terminamos, nuestro próximo movimiento es ejecutar $(bitor xor) nuevamente. Esto produce 0 si los caracteres de entrada son los mismos, 1 de lo contrario. Luego multiplicamos acon este resultado, dando 0 o a. Como *está en una unión, este valor de la pila superior determina lo que sucede a continuación.

En el caso 0, seguimos adelante y ejecutamos tres "no-ops, antes de realizar una (disminución. Al igual que la configuración, esto nos hace girar y ejecutar "*$, dejándonos listos para leer más caracteres.

De lo contrario, en el acaso, giramos a la derecha en el cruce ya que aes positivo (48 o 49). .genera el carácter, dejando la pila vacía y (disminuye la parte superior de la pila, convirtiendo un 0 en -1. Una vez más, esto nos hace girar a la izquierda, ejecutar "*$como en la configuración, y también nos deja listos para leer más entradas.

CJam, 10 8 bytes

l2/{)-}%

Pruébalo aquí.

Explicación

Esta es una solución muy simple: en cada par, elimine todas las instancias del último carácter. Los dígitos repetidos y los dígitos finales no apareados se eliminarán, al igual que el segundo dígito en cualquier par de dígitos desiguales:

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

Esto deja solo los dígitos que estamos buscando. Así es como el código calcula esto:

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

Cuando la lista se imprime automáticamente al final del programa, las cadenas vacías simplemente se omiten.

Perl, 19 18 17 bytes

La solución Retina @Martin Büttner inspiró una ganancia de 2 bytes

Incluye +1 para -p

Ejecutar con la entrada en STDIN, p. Ej. perl -p fair.pl <<< 11000110

fair.pl:

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

No hay mucho que explicar aquí, ya que es una traducción (indirecta) de la especificación:

• (.)\1 Si los primeros 2 dígitos son iguales, suéltelos
• .\K. De lo contrario, los dos primeros dígitos son diferentes. Mantener ( \K) el primero
• .?\K.Excepto que el primero .es opcional. Esto permite una sola coincidencia al final de la cadena que luego se descarta ya que la parte guardada está vacía

Mathematica, 36 38 bytes

-2 después de robar la función de @ LegionMammal978 para determinar si una lista de 2 elementos es {0,1} o {1,0}

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

Se espera que el argumento sea una lista de enteros.

Hexagonía , 23 21 bytes

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

Desplegado:

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

Esto termina con un error, pero el mensaje de error va a STDERR.

Pruébalo en línea!

A juzgar por la cantidad de espejos, podría ser posible encajarlo en la longitud lateral 3, pero hasta ahora no he tenido suerte.

Explicación

Aquí está el diagrama habitual, generado con el HexagonyColorer de Timwi :

El programa utiliza sólo tres bordes de memoria, marcado con A , B , y C aquí (diagrama de cortesía de de Timwi EsotericIDE ):

La ejecución comienza en el camino azul. El /son sólo espejos que redirigen el puntero de instrucción (IP), el código real es:

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

El ,establecerá el borde a -1en lugar del código de caracteres, si hemos golpeado EOF. Dado que estamos incrementando ambas entradas que no cambian si son iguales o no, pero convierte EOF en 0.

Usamos módulo para verificar la igualdad, porque es 1o 49(positivo) para caracteres desiguales y 0para caracteres iguales. También sirve como el final del programa, porque cuando tenemos el 0de EOF, el intento de división por cero causará un error.

Ahora el <distingue los ceros de los resultados positivos. El simple primero: si los caracteres son iguales, la IP toma el camino rojo. _es un espejo, \también es un espejo, pero se ignora y >desvía la IP de modo que se enrolla en los bordes y comienza desde la parte superior nuevamente. Sin embargo, en esta iteración, los roles de A , B y C se intercambian cíclicamente ( C ahora toma el rol de A y así sucesivamente).

Si los caracteres son diferentes, se toma el camino verde en su lugar. Este es un poco más desordenado. Primero salta sobre un no-op con $, luego se envuelve hacia el /borde izquierdo, luego atraviesa la penúltima fila de derecha a izquierda y finalmente vuelve a ingresar la parte interesante del código fuente en el {. Hay un bit de código esencialmente lineal, que explicaré en un segundo, antes de $que la IP salte sobre el >para fusionar las dos rutas nuevamente.

Aquí está ese código lineal:

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

Tenga en cuenta que en este caso, los roles de los bordes para la próxima iteración también se intercambian cíclicamente, pero con B tomando el rol de A y así sucesivamente.

Haskell, 71 44 29 bytes

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

Golf extremo por nimi .

> <> , 11 bytes

i:i:0(?;-?o

> <> se adapta bastante bien a desafíos de leer un char-at-a-time como este :) ¡ Pruébelo en línea!

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)

Todo esto sucede en un bucle ya que el puntero de instrucción se ajusta una vez que llega al final de una línea.

Python, 42 bytes

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

Diversión con recursividad y bitor xor. Toma una lista de 1s y 0s como entrada.

JavaScript (ES6), 33 bytes

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

Cómo funciona

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 bytes

11(-(#!)?^?)

Esto supone un intérprete que lee e imprime caracteres. Puede intentarlo en línea. Pero ese intérprete imprime enteros, así que para cada 0uno obtendrá 48y para cada 1uno obtendrá en su 49lugar (y un salto de línea).

Explicación

Es muy raro que pueda escribir un programa no trivial en una sola línea en Prelude (porque Prelude necesita más de una línea para completar Turing).

11      Push two 1s. We need something non-zero on the stack to enter the loop, and by
        pushing the same value twice, we make sure that the loop doesn't print anything
        on the first iteration.
(       Main loop...
  -       Subtract the last two values. This will be zero for equal values, and non-zero
          otherwise...
  (       This "loop" is simply used as a conditional: if the last two values were
          were equal, skip the code inside...
    #       Discard the conditional.
    !       Print the value below.
  )       The loop is exited because the value below is always zero.
  ?       Read the first character of the next pair from STDIN.
  ^       Duplicate it, so the lower copy can be printed.
  ?       Read the second character of the pair. This returns 0 at EOF, which
          terminates the loop.
)

Perl, 27 21 bytes

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

Byte agregado para la -nbandera.

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

Prueba:

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

1



1101001
0
1011101010
1111

¡Gracias a @TonHospel por 6 bytes!

Befunge 93 , 16 bytes

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

Una línea para la compacidad. Probado con este intérprete en línea .

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

La última parte hace uso del hecho de que saltar de una pila Befunge-93 vacía produce 0 .

Si a != b , realizamos

>                      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

De lo contrario, si a == b, realizamos:

>                      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

Algoritmo robado descaradamente de la respuesta de Dennis's Jelly .

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

Python 2, 48 bytes

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

Pruébalo en línea

Gracias a Dennis y Vaultah por señalar cosas que me perdí

Mathematica, 41 39 bytes

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

Menos complicado y más corto que la otra respuesta. El cuadro es un carácter de transposición.

JavaScript (ES6), 33 bytes

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

Aburrido puerto de la Retina respuesta.

sed, 34 33 bytes

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

Prueba:

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

1



1101001
0
1011101010
1111

Laberinto , 31 bytes

No es tan corto y ordenado como la solución de Sp3000, pero pensé en publicar esto de todos modos como un enfoque diferente:

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

Explicación

El primer bucle es simplemente

""
,,

que se lee en dos caracteres a la vez (el " son no-ops). Después de EOF, ,volverá -1, pero solo verificará si hay EOF en cada segundo personaje. Eso significa que, en cualquier caso, la parte superior de la pila será entonces -1y el valor a continuación es-1 o algún código de caracteres que no nos importa, porque es un lanzamiento de moneda no emparejado.

Luego )* convierte el -1y el valor a continuación en uno solo 0que necesitamos a) para deshacernos de esos dos valores yb) para ingresar el siguiente ciclo correctamente. El siguiente ciclo es simplemente

"}
""

Lo que desplaza todos los valores a la pila auxiliar. Esto es necesario porque queremos comenzar a procesar los pares que leemos primero. Ahora el bucle final:

:{"
{ $;
)";.

El )solo incrementa un valor ficticio para asegurar que sea positivo y el puntero de instrucción gire hacia el norte. {detiene el primer dígito del siguiente par y lo :duplica. Ahora, cuando terminemos de procesar, esto habrá sido un0 desde la parte inferior de la pila auxiliar. De lo contrario, es 48o 49. En caso de cero, salimos del bucle y terminamos @, de lo contrario, la IP gira hacia el este.

{detiene el otro dígito del par actual. $toma el XOR entre ellos. Si eso es 0, es decir, los dos son iguales, la IP simplemente continúa moviéndose hacia el sur, ;descarta el cero y la IP gira hacia el oeste en la siguiente iteración. Si el XOR era 1, es decir, eran diferentes, la IP gira hacia el oeste, descarta el 1con ;e imprime el primer dígito con ..

MATL , 11 9 8 bytes

`-?6MD]T

Entrada y salida son números separados por nuevas líneas. Finaliza con un error (permitido de manera predeterminada) cuando se han consumido todas las entradas.

Pruébalo en línea!

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

Enfoque antiguo, 11 bytes

2YCd9L)Xz0<

La entrada es una cadena. La salida es números separados por nuevas líneas.

Pruébalo en línea!

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

Esto separa l[0], l[1]y l[2..{end}]como a, by c. Luego crea una cadena con asi a!=bo de lo ''contrario y f[c]si c[0]existe o de lo ''contrario.

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

Sin golf:

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

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

En comparación con Java, esto es muy compacto, sin embargo, me temo que responda al golfista mental. Y siéntase libre de mencionar si hay un error. Suponiendo que EOF es 0, la entrada no contiene una entrada no válida, la celda es inicialmente cero y el rango de valores de la celda es finito y cíclico. Ninguna otra suposición está presente.

Explicación:

Mapa de celdas de memoria

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

Instrucción

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

Función anónima que ingresa y emite listas de ceros y unos.

Pyth, 10 bytes

hMf!qFTcz2

Banco de pruebas

C, 66 bytes

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

Asumiendo sizeof(int) == sizeof(char *)

solución "inteligente" - 84 81 bytes

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

Funciona en máquinas little-endian suponiendo que shortsea ​​de 2 bytes. La entrada se pasa como argumento. El programa itera sobre pares de caracteres e imprime 0 para 0x3130 y 1 para 0x3031. En big-endian, el resultado se invertirá (reemplace 48|c&1con 49^c&1para arreglar esto).

C, 57 bytes

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

Copiamos tentativamente un carácter de la entrada pal resultado r, pero solo avanzamos el rpuntero si difiere del siguiente carácter. De lo contrario, lo sobrescribiremos en el siguiente par no coincidente, o conNUL al final.

Programa de prueba:

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

Prueba de salida:

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

Puedes probarlo aquí . Pegue el código en el espacio debajo del botón "mostrar", presione "mostrar", defina la entrada, presione "ejecutar". Usamos el botón "paso" para ver cómo funciona el programa.

Lote DOS / Windows, 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

La entrada es una cadena separada por espacios, por ejemplo 1 0 0 1 1. Comience desde cmd, de lo contrario la pantalla se cerrará inmediatamente

cera de abejas ,45 35 bytes

Podría jugar golf por 10 bytes, no está mal.

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

Tomé la lectura como un enfoque completo de lanzamiento de monedas , lo que hace que el programa sea bastante grande. Solo leer enteros individuales uno por uno haría que el programa fuera más pequeño, tal vez alrededor de 22 bytes más o menos, pero también sería muy inconveniente de usar.

Ejemplos:

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!

Mi repositorio GitHub de cera de abejas.

Mis ejemplos de cera de abejas en el código de Rosetta.