Vous avez une pièce qui produit 0ou 1. Mais vous soupçonnez que la pièce peut être biaisée , ce qui signifie que la probabilité de 0(ou 1) n'est pas nécessairement 1/2.

Une procédure bien connue pour "transformer" une pièce biaisée en une pièce équitable (c'est-à-dire pour obtenir des résultats également probables), telle que proposée par von Neumann, est la suivante. Produisez des blocs (ne se chevauchant pas) de deux lancers de pièces jusqu'à ce que les deux valeurs d'un bloc diffèrent; et affiche la première valeur de ce bloc (la deuxième valeur ferait également l'affaire, mais pour les besoins de ce défi, nous choisissons la première). Intuitivement, 1peut être plus probable que 0, mais 01et 10sera tout aussi probable.

Par exemple, l’entrée 1110...jetterait le premier bloc, puis produirait un à 1partir du deuxième bloc, ...

Cette procédure est coûteuse , car plusieurs lancers de pièces sont consommés pour générer un seul résultat.

Le défi

Prenez une séquence finie de zéros et de uns, représentant les lancers de la pièce d'origine, et produisez le nombre maximum de résultats conformément à la procédure ci-dessus, jusqu'à ce que toutes les entrées soient consommées.

Le dernier bloc peut être incomplet si le nombre de valeurs entrées est impair. Par exemple, la séquence d'entrée ne 11111donnerait aucun résultat (les deux premiers blocs ont des valeurs égales et le troisième est incomplet).

Règles

L'entrée peut avoir un nombre non négatif de valeurs, pas nécessairement positives ni même.

Le format d'entrée peut être:

• un tableau de zéros et de uns;
• une chaîne de zéros et des uns avec un séparateur facultatif.

Le format de sortie peut être:

• une chaîne de zéros et de uns, avec ou sans séparateurs;
• un tableau de zéros et de uns;
• chaînes contenant un seul zéro ou un, séparées par des nouvelles lignes;
• tout format similaire, raisonnable et adapté à votre langue.

Code de golf. Le moins d'octets gagne.

Cas de test

L'entrée et la sortie sont supposées être des chaînes.

Input         -->  Output

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

Gelée, 6 octets

s2Q€Ṗ€

Essayez-le en ligne!

Comment ça marche

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.

Rétine , 16 à 14 octets

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

Essayez-le en ligne!

Explication

C'est assez simple. Le code définit une substitution de regex unique remplaçant toutes les correspondances (sans chevauchement) de (.)\1|(.)?.quel que soit le deuxième groupe capturé. Cela combine trois cas différents en un seul:

(.)\1 --> <empty>

Si deux chiffres répétés sont égaux, nous les supprimons de la chaîne (car le groupe 2 n'est pas utilisé).

(.).  --> $2

Sinon, si nous pouvons faire correspondre deux caractères, supprimez le deuxième en les remplaçant par le premier. Si ce n'est pas le cas, le groupe ?sera omis:

.     --> <empty>

Cela ne se produit que s'il existe un caractère de fin non associé, qui est également supprimé.

Labyrinthe , 21 12 octets

"(. :
""*$,@

Un exemple rare d'un programme Labyrinth compact qui ne comporte pas non plus d'opportunités. La |version précédente était totalement inutile et sa suppression réduisait considérablement la taille du programme. En fait, Lab bat Retina!

Essayez-le en ligne!

Le coin inférieur gauche "peut aussi être un espace, mais son utilisation simplifie grandement l'explication.

Explication

Celui-ci est un peu plus compliqué, donc il est accompagné d'images. Mais tout d’abord, une introduction rapide:

• Labyrinth est un langage 2D basé sur des piles. La mémoire est constituée d’une pile principale et d’une pile auxiliaire.
• Les piles de Labyrinth étant sans fond et remplies de zéros, effectuer des opérations sur une pile vide n'est pas une erreur.
• À chaque jonction, où il existe deux chemins ou plus pour le pointeur d'instruction, le haut de la pile principale est vérifié pour déterminer la prochaine étape. Le négatif est à gauche, le zéro à droite et le positif à droite. Si un virage échoue, le pointeur tente de faire demi-tour.

Installer

Le programme commence en haut à gauche ", ce qui est une non-opération. Ensuite, nous effectuons:

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

Cela laisse la pile avec un seul 0, ce qui est presque vide pour les besoins de Labyrinth.

Lecture d'entrée et de terminaison

,lit un caractère à partir de l'entrée, renvoyant 48 ou 49 pour 0ou 1respectivement, et -1 sur EOF. Comme ceci est différent de zéro, dans les deux cas, nous nous tournons vers le :qui duplique le haut de la pile.

Le :est dans une impasse, alors nous nous retournons et exécutons ,une fois de plus. Maintenant , si la dernière entrée était EOF, nous tournons à gauche et se terminent par @, sinon on tourne à droite, avec la pile ressemblant [a a b](où a, bsont les deux caractères).

Interprétation du tirage au sort

Si nous ne terminons pas, notre prochain mouvement est d'exécuter à nouveau $(bitwise xor). Cela donne 0 si les caractères d'entrée étaient les mêmes, 1 sinon. Nous multiplions ensuite aavec ce résultat, donnant 0 ou a. Puisque le *est à une jonction, cette valeur de pile supérieure détermine ce qui se passera ensuite.

Dans le cas 0, nous allons tout droit et exécutons trois "no-ops avant d'effectuer une (décrémentation. Comme pour la configuration, cela nous fait tourner et exécuter "*$, nous laissant prêts à lire plus de caractères.

Sinon, dans le acas, on tourne à droite à la jonction puisque aest positif (48 ou 49). .sort le caractère, laissant la pile vide, et (décrémente le haut de la pile, en tournant de 0 à -1. Encore une fois, cela nous fait tourner à gauche, en procédant "*$comme dans la configuration, nous laissant également prêts à lire plus d’entrées.

CJam, 10 à 8 octets

l2/{)-}%

Testez-le ici.

Explication

C'est une solution très simple: dans chaque paire, supprimez toutes les occurrences du dernier caractère. Les chiffres répétés et les derniers chiffres non appariés seront supprimés, de même que le deuxième chiffre de toute paire de chiffres inégaux:

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

Cela ne laisse que les chiffres que nous recherchons. Voici comment le code calcule ceci:

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

Lorsque la liste est automatiquement imprimée à la fin du programme, les chaînes vides sont simplement omises.

Perl, 19 18 17 octets

La solution @Martin Büttner Retina a inspiré un gain de 2 octets

Comprend +1 pour -p

Exécuter avec l'entrée sur STDIN, par exemple perl -p fair.pl <<< 11000110

fair.pl:

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

Pas grand chose à expliquer ici puisqu'il s'agit d'une traduction (indirecte) de la spécification:

• (.)\1 Si les 2 premiers chiffres sont identiques, supprimez-les
• .\K. Sinon, les deux premiers chiffres sont différents. Gardez ( \K) le premier
• .?\K.Sauf que le premier .est optionnel. Cela permet une seule correspondance à la fin de la chaîne, qui est ensuite rejetée car la partie conservée est vide.

Mathematica, 36 38 octets

-2 après avoir volé la fonction de @ LegionMammal978 pour déterminer si une liste à 2 éléments est {0,1} ou {1,0}

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

L'argument devrait être une liste d'entiers.

Hexagone , 23 21 octets

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

Déplié:

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

Cela se termine par une erreur, mais le message d'erreur passe à STDERR.

Essayez-le en ligne!

À en juger par le nombre de miroirs, il serait peut-être presque possible de l'adapter à la longueur de côté 3, mais je n'ai pas eu de chance jusqu'à présent.

Explication

Voici le diagramme habituel, généré avec HexagonyColorer de Timwi :

Le programme utilise trois bords de mémoire, étiquetés A , B et C ici (avec l' aimable autorisation de diagramme de Timwi EsotericIDE ):

L'exécution commence sur le chemin bleu. Ce ne /sont que des miroirs qui redirigent le pointeur d'instruction (IP), le code actuel est le suivant:

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

Le ,mettra le bord à la -1place du code du caractère si nous avons atteint EOF. Puisque nous incrémentons les deux entrées, elles ne changent pas si elles sont égales ou non, mais cela transforme EOF en 0.

Nous utilisons modulo pour vérifier l'égalité, parce qu'il est soit 1ou 49(positif) pour les caractères inégaux et 0des caractères égaux. Il sert également de fin du programme, car lorsque nous avons le0 de EOF, la tentative de division par zéro provoquera une erreur.

Maintenant, on <distingue les zéros des résultats positifs. Le plus simple en premier: si les caractères sont égaux, l’IP prend le chemin rouge. _est un miroir, \est aussi un miroir mais est ignoré et >dévie l'adresse IP de telle sorte qu'elle s'enroule autour des bords et recommence du haut. Cependant, sur cette itération, les rôles de A , B et C sont permutés de manière cyclique ( C prend maintenant le rôle de A , etc.).

Si les caractères sont différents, le chemin vert est pris à la place. Celui-ci est un peu plus en désordre. Il saute d'abord sur un no-op avec $, puis s'enroule /sur le bord gauche, puis traverse l'avant-dernière ligne de droite à gauche et rentre enfin dans la partie intéressante du code source {. Il y a un morceau de code essentiellement linéaire, que je vais expliquer dans une seconde, avant que $l'adresse IP ne saute par dessus >pour fusionner à nouveau les deux chemins.

Voici ce morceau de code linéaire:

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

Notez que dans ce cas, les rôles des arêtes pour la prochaine itération sont également permutés de manière cyclique, mais B prenant le rôle de A , etc.

Haskell, 71 44 29 octets

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

Golf extrême par nimi .

> <> , 11 octets

i:i:0(?;-?o

> <> est plutôt bien adapté aux défis de lecture à la fois, comme celui-ci :) Essayez-le en ligne!

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)

Tout cela se passe dans une boucle car le pointeur d'instruction tourne autour une fois qu'il atteint la fin d'une ligne.

Python, 42 octets

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

Amusez-vous avec la récursivité et le bitor xor. Prend une liste de 1 et de 0 en entrée.

JavaScript (ES6), 33 octets

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

Comment ça marche

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.

Prélude , 12 octets

11(-(#!)?^?)

Cela suppose un interprète qui lit et imprime les caractères. Vous pouvez en quelque sorte l'essayer en ligne. Mais cet interprète imprime des nombres entiers, donc pour chacun 0vous obtiendrez 48et pour chacun 1vous obtiendrez à la 49place (et un saut de ligne).

Explication

Il est très rare que vous puissiez écrire un programme non trivial sur une seule ligne dans Prelude (car Prelude a besoin de plus d'une ligne pour être complet de 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 octets

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

Octet ajouté pour le -ndrapeau.

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

Tester:

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

1



1101001
0
1011101010
1111

Merci à @TonHospel pour 6 octets!

Befunge 93 , 16 octets

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

Une ligne pour la compacité. Testé à l'aide de cet interprète en ligne .

~:                     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 dernière partie utilise le fait que le fait de sauter d’une pile Befunge-93 vide donne 0 .

Si a != b, nous effectuons

>                      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

Sinon, si a == bnous effectuons:

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

jkPM{Mcz2

Algorithme volé sans vergogne de la réponse de Dennis à 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 octets

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

Essayez-le en ligne

Merci à Dennis et vaultah pour avoir signalé des choses qui me manquaient

Mathematica, 41 39 octets

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

Moins compliqué et plus court que l'autre réponse. La boîte est un caractère de transposition.

JavaScript (ES6), 33 octets

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

Port ennuyeux de la réponse de la rétine.

sed, 34 33 octets

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

Tester:

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

1



1101001
0
1011101010
1111

Labyrinthe , 31 octets

Pas aussi courte et soignée que la solution de Sp3000, mais je pensais poster cela comme une approche différente:

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

Explication

La première boucle est simplement

""
,,

qui lit en deux caractères à la fois (les "sont no-ops). Après EOF, ,reviendra -1, mais ne vérifiera que pour EOF tous les deux caractères. Cela signifie que dans tous les cas, le haut de la pile sera alors -1et la valeur ci-dessous est soit-1 code ou un code de caractère qui ne nous intéresse pas, car il s'agit d'un tirage au sort non apparié.

)*Transforme ensuite -1les valeurs et la valeur ci-dessous en une seule 0dont nous avons besoin a) pour supprimer ces deux valeurs et b) pour entrer correctement dans la boucle suivante. Cette prochaine boucle est tout simplement

"}
""

Ce qui déplace toutes les valeurs sur la pile auxiliaire. Cela est nécessaire car nous voulons commencer à traiter les paires que nous avons lues en premier. Maintenant la dernière boucle:

:{"
{ $;
)";.

Le )simple incrémente une valeur factice pour s'assurer qu'elle est positive et que le pointeur d'instruction se tourne vers le nord. {tire sur le premier chiffre de la paire suivante et le :duplique. Maintenant, lorsque nous aurons terminé le traitement, cela se fera 0du bas de la pile auxiliaire. Sinon, c'est soit 48ou 49. Dans le cas d'un zéro, nous sortons de la boucle et nous terminons le @, sinon, l'IP tourne à l'est.

{tire sur l'autre chiffre de la paire actuelle. $prend le XOR entre eux. Si c'est 0, c'est-à-dire que les deux sont égaux, l'adresse IP continue simplement de se déplacer vers le sud, ;ignore le zéro et l'adresse IP se tourne vers l'ouest pour la prochaine itération. Si le XOR était différent 1, c’est-à-dire que l’IP tourne à l’ouest, rejette le 1avec ;et affiche le premier chiffre avec ..

MATL , 11 9 8 octets

`-?6MD]T

L'entrée et la sortie sont des nombres séparés par des nouvelles lignes. Se termine par une erreur (autorisée par défaut) lorsque toutes les entrées ont été consommées.

Essayez-le en ligne!

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

Ancienne approche, 11 octets

2YCd9L)Xz0<

L'entrée est une chaîne. La sortie est composée de nombres séparés par des nouvelles lignes.

Essayez-le en ligne!

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 octets

Cela sépare l[0], l[1]et l[2..{end}]comme a, bet c. Ensuite, il crée une chaîne avec aif a!=bou ''sinon et f[c]si c[0]existe ou ''non.

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 octets

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

Comparé à Java, c'est très compact, cependant, j'ai peur du répondeur brainfuck-golfeur. Et n'hésitez pas à mentionner s'il y a un bug. En supposant que EOF soit égal à 0, l'entrée ne contient pas d'entrée non valide, la cellule est initialement égale à zéro et la plage de valeurs de la cellule est finie et cyclique. Aucune autre hypothèse n'est présente.

Explication:

Carte des cellules de mémoire

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

Instruction

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

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

Fonction anonyme qui entre et sort des listes de zéros et de uns.

Pyth, 10 octets

hMf!qFTcz2

Suite de tests

C, 66 octets

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

En supposant sizeof(int) == sizeof(char *)

solution "intelligente" - 84 81 octets

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

Fonctionne sur une machine little-endian en supposant short2 octets. L'entrée est passée en argument. Le programme parcourt des paires de caractères et affiche 0 pour 0x3130 et 1 pour 0x3031. Sur big-endian, le résultat sera inversé (remplacez 48|c&1par 49^c&1pour résoudre ce problème).

C, 57 octets

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

Nous copions provisoirement un caractère d’entrée pen résultat r, mais ne faisons avancer le rpointeur que s’il diffère du caractère suivant. Sinon, nous l'écraserons à la prochaine paire sans correspondance ou avecNUL à la fin.

Programme de 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;
}

Test de sortie:

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

Befunge-93 , 40 octets

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

Vous pouvez l' essayer ici . Collez le code dans l’espace sous le bouton "Afficher", appuyez sur "Afficher", définissez la saisie, appuyez sur "Exécuter". Nous utilisons le bouton "step" pour voir comment le programme fonctionne.

Batch DOS / Windows, 201 162 octets

@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'entrée est une chaîne séparée par un espace, par exemple 1 0 0 1 1. Commencez à partir de cmd, sinon l'écran se ferme immédiatement

cire d'abeille ,45 35 octets

Je pourrais jouer au golf par 10 octets - pas trop mal.

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

J'ai pris la lecture d'une chaîne complète de lancer de pièces approche , ce qui rend le programme assez volumineux. Le simple fait de lire des entiers un par un rendrait le programme plus petit (environ 22 octets environ), mais aussi très pratique à utiliser.

Exemples:

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!

Mon dépôt GitHub de cire d'abeille.

Mes exemples de cire d'abeille sur Rosetta Code.