introduction

Classiquement, les booléens sont un bit; trueou false, 1ou 0. Les zéros non significatifs seraient simplement redondants. Par exemple, 001signifie la même chose que 00001ou juste 1.

Le booléen 32 bits

Étant donné une valeur truey / falsey, sortez l'équivalent booléen 32 bits sous forme de chaîne. (Ou sous forme de nombre si, pour une raison quelconque, votre langue prend en charge les zéros non significatifs.)

Votre programme ne doit pas fonctionner pour tous les types de vérités / fausses, mais uniquement pour ce que votre langage de programmation fonctionne le mieux.

Exemple i / o

Input >> Output

truthy >> 00000000000000000000000000000001
falsey >> 00000000000000000000000000000000

Il s'agit de code-golf , donc les octets les plus bas gagnent!

Python 3 , 33 25 18 15 octets

Merci @ jurjen-bos pour l' __mod__astuce.

'%.32d'.__mod__

Essayez-le en ligne!

Code machine x86-16 (DOS), 16 octets

B4 02          mov  ah,  2
B2 30          mov  dl, '0'
B9 1F 00       mov  cx, 31

            PrintZeros:
CD 21          int  0x21
E2 FC          loop PrintZeros

00 CA          add  dl, bl
CD 21          int  0x21
C3             ret

La fonction ci-dessus reçoit une valeur booléenne (0 == falsey, 1 == truey) dans le BLregistre (octet bas de BX) et imprime une chaîne "booléenne redondante" sur la sortie standard.

Il fonctionne en appelant une interruption (0x21) pour effectuer un appel de fonction DOS (sélectionné en définissant AHsur 2) qui imprime un seul caractère (in DL) sur la sortie standard.

Tout d'abord, le caractère ASCII «0» est chargé dans DL, le compteur ( CX) est défini sur 31 et il boucle pour imprimer les octets «redondants». Ensuite, la valeur booléenne d'entrée est ajoutée à DL(s'il BLs'agit de falsey, l'ajout de 0 restera DLinchangé en tant que ASCII '0'; s'il BLest véridique, DLsera incrémenté de un à ASCII '1'), et l'octet final sera imprimé.

La fonction ne renvoie pas de valeur.

Assez décent pour une langue qui ne fait pas vraiment de cordes.

Programme complet, 21 octets

Si vous voulez en faire un programme complet, seulement 5 octets supplémentaires sont nécessaires. Au lieu de passer l'entrée dans un registre, cela lit l'entrée des arguments passés sur la ligne de commande lors de l'appel de l'application. Un argument de 0 est interprété comme falsey, tout comme l'absence totale d'arguments; un argument supérieur à 0 est interprété comme véridique.

Assemblez simplement le code suivant en tant que programme COM, puis exécutez-le sur la ligne de commande.

B4 02            mov   ah,  2
B2 30            mov   dl, '0'
B9 1F 00         mov   cx, 31

               PrintZeros:
CD 21            int   0x21
E2 FC            loop  PrintZeros

3A 16 82 00      cmp   dl, BYTE PTR [0x82]  ; compare to 2nd arg, at offset 0x82 in PSP
D6               salc                       ; equivalent to sbb al, al
28 C2            sub   dl, al
CD 21            int   0x21
C3               ret                        ; you can simply 'ret' to end a COM program

Exemple de sortie:

C:\>bool.com
00000000000000000000000000000000
C:\>bool.com 0
00000000000000000000000000000000
C:\>bool.com 1
00000000000000000000000000000001 
C:\>bool.com 2
00000000000000000000000000000001
C:\>bool.com 7
00000000000000000000000000000001

Comment ça marche? Eh bien, c'est essentiellement la même chose, jusqu'à ce que vous arriviez à l' CMPinstruction. Cela compare l'argument de ligne de commande avec la valeur du DLregistre (qui, vous vous en souvenez, contient un «0» ASCII). Dans un programme COM, les octets de code sont chargés à l'offset 0x100. Il s'agit du préfixe de segment de programme (PSP) , qui contient des informations sur l'état d'un programme DOS. Plus précisément, à l'offset 0x82, vous trouvez le premier argument (en fait le second, car le premier est un espace) qui a été spécifié sur la ligne de commande lorsque le programme a été appelé. Donc, nous comparons simplement cet octet avec un «0» ASCII.

La comparaison définit les indicateurs, puis l' SALCinstruction (un opcode non documenté avant le Pentium, équivalent à sbb al, al, mais seulement 1 octet au lieu de 2) prend la valeur AL0 si les deux valeurs sont égales, ou -1 si elles sont différentes. Il est alors évident que lorsque nous soustrayons ALde DL, cela se traduit par ASCII «0» ou «1», selon le cas.

(Notez que, quelque peu ironiquement, vous le casserez si vous passez un argument avec un 0 de tête sur la ligne de commande, car il ne regarde que le premier caractère. Il 01sera donc traité comme falsey. :-)

Python 3 , 23 octets

lambda n:'0'*31+'01'[n]

Essayez-le en ligne!

Javascript, 23 octets

a=>'0'.repeat(31)+ +!!a

!!a transforme un en booléen, que l'unaire plus transforme en int.

V , 8 octets

32é0Àñl

Essayez-le en ligne!

Explication:

32é0            " Insert 32 '0's
    Àñ          " Arg1 times...
      <C-a>     "   Increment the number under the cursor
           l    "   Move one char to the right. This will break the loop since there is 
                "   no more room on this line

Neim , 6 5 octets

ᛝΨβ_I

Essayez-le en ligne!

Explication:

 ᛝ        # Constant 31
  Ψ       # Apply next token to all in list
    β     # Constant 0
     _    # Push each element to stack
      I   # Take Line of input.

Un octet enregistré grâce à Okx

Octave , 17 octets

@(n)dec2bin(n,32)

Fonction anonyme. Fonctionne également dans MATLAB.

Essayez-le en ligne!

ArnoldC , 369 octets

IT'S SHOWTIME
HEY CHRISTMAS TREE A
YOU SET US UP 0
GET YOUR ASS TO MARS A
DO IT NOW
I WANT TO ASK YOU A BUNCH OF QUESTIONS AND I WANT TO HAVE THEM ANSWERED IMMEDIATELY
BECAUSE I'M GOING TO SAY PLEASE A
TALK TO THE HAND "00000000000000000000000000000001"
BULLSHIT
TALK TO THE HAND "00000000000000000000000000000000"
YOU HAVE NO RESPECT FOR LOGIC
YOU HAVE BEEN TERMINATED

Essayez-le en ligne!

Brainfuck , 61 60 36 octets

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

Je suis sûr qu'il existe un moyen intelligent de ne pas trop se déplacer avec les pointeurs.

J'avais raison. Il y avait. Merci à @Graviton de m'avoir donné l'idée!

Étape suivante: obtenez les valeurs 32 et 48 plus rapidement!

Essayez-le en ligne!

++++        - Increment 1st slot by 4
[           - Loop until 4 becomes 0
    >++++   - Add 4 to 2nd slot
    <-      - Decrement loop
]           - At this point, we point to slot 1 and slot 2 contains 16, which is the Greatest Common Divisor of 48 (value 0 in ASCII) and 32 (final length of answer)
>           - Point to value 16 (slot 2)
[           - Start loop to get our target values 32 and 48
    >++     - Point to slot 3 and multiply 16 by 2 = 32
    >+++    - Point to slot 4 and multiply 16 by 3 = 48
    <<-     - Decrement the loop so that slot 2 becomes 0
]           - We now point slot 2
>-          - Move to slot 3 and remove one so we can spam (output) 31 zeroes
[           - Start outputting until slot 3 is empty
    >.      - Move to slot 4 where our ASCII value for 0 is
    <-      - Decrement the loop so that slot 3 becomes 0
]           - We are now at slot 3 and it is empty.
,.          - We can now gather input from the user and output it.

C'était amusant pour un premier golf!

Il est devenu trop tard maintenant. Qu'est-ce que je fais même

Scala, 32 octets

Désolé mais j'ai été obligé de le faire en 32 octets> _ <

var s=t
for(u<-0 to 30)s="0"+s
s

Il est entouré par une fonction prenant tcomme paramètre (comme un stringqui peut être "0" ou "1" pour resp. Fausses ou véridiques), et sest retourné.

Essayez-le en ligne!

Réponse valide: Scala, 46 octets

Identique à ma réponse java, je devais prendre un booléen pour le paramètre. Donc :

var s=if(t)"1"else"0"
for(u<-0 to 30)s="0"+s
s

Essayez-le en ligne!

Braingolf , 10 8 octets

#␟>[0_]N

Essayez-le en ligne!

␟est un séparateur d'unités, ASCII 0x1Fou 31. Impossible de trouver le caractère à coller dans TIO, donc TIO utilise à la place # 1-, ce qui pousse l'espace (32) et diminue à 31.

Explication

#␟>[0_]N  Implicit input from commandline args
#␟        Push unit separator (31)
   >       Move top item to bottom of stack
    [..]   Loop, runs 31 times
     0_    Print 0
        N  Boolean conversion, truthy values become 1, falsey values become 0
           Implicit output of top of stack

Octave , 23 octets

@(x)[48+[!(1:31),x],'']

Essayez-le en ligne!

C'est plus court que toutes les approches avec lesquelles j'ai essayé printf. J'ai peut-être manqué quelque chose, puisque je l'ai fait sur mon téléphone.

Un seul octet de plus

@(x)[dec2bin(0,31),x+48]

Cela pourrait être de 18 octets si je pouvais prendre 1/0 comme chaînes.

@(x)[48+!(1:31),x]

Essayez-le en ligne!

Java 8, 31 27 octets

b->"".format("%032d",b?1:0)

-4 octets grâce à @ OlivierGrégoire .

Essayez-le ici.

05AB1E , 5 octets

¾31׫

Essayez-le en ligne!

Rubis, 21 octets

Oui, cet espace doit être là ..: /

->x{"%032b"%(x ?1:0)}

En Ruby tout sauf falseet nilest véridique; Essayez-le en ligne!

Mathematica, 36 octets

""<>ToString/@PadLeft[{Boole@#},31]&

Mathematica, 26 octets

Row@PadLeft[{Boole@#},31]&

Essayez-le en ligne!

Fusain , 5 octets

×0³¹Ｓ

Essayez-le en ligne! (Lien vers la version détaillée.)

Comme le charbon de bois comprend 0et 1comme Trueou False, cela affiche seulement 31 0s et l'entrée ( 0ou 1) sous forme de chaîne.

Python 2 , 26 25 octets

Merci à Erik l'Outgolfer d' avoir sauvé un octet!

Opte pour l'approche programme complète:

print+bool(input(31*'0'))

Essayez-le en ligne!

Indésirable, inutile, opportuniste , 7 octets

P0M31P*

Passez 1 ou 0 dans le registre.

C, 26 octets

À peu près la même idée que la solution de 1bluestone , mais en C, elle est plus courte et fonctionne correctement pour toute entrée entière:

f(a){printf("%032i",!!a);}

Bien sûr, cela inclut certaines variables / fonctions typées implicitement comme le font toutes les bonnes réponses de C-golf ... L' !!opérateur est le moyen le plus court pour convertir n'importe quelle valeur véridique 1en C (via la double négation, il !est défini pour retourner soit 1ou 0).

Testez avec:

#include <stdio.h>
f(a){printf("%032i",!!a);}
int main() {
    f(0), printf("\n");
    f(1), printf("\n");
    f(2), printf("\n");
    f(-1), printf("\n");
}

Haskell , 37 32 octets

(('0'<$[1..31])++).show.fromEnum

Essayez-le en ligne!

Merci @nimi pour les -5octets!

PHP, 28 octets

<?=str_pad($argv[1],32,0,0);

Enregistrez sous bool.php et exécutez:

$ php bool.php 0
00000000000000000000000000000000
$ php bool.php 1
00000000000000000000000000000001

Ly , 20 15 13 octets

65*1+[0u1-]nu

EDIT: 5 octets enregistrés grâce aux ovs.
EDIT: enregistré 2 octets supplémentaires en imprimant 0 sous forme de nombre plutôt que de caractère.

Octave, 16 11 octets

@(x)x(1:32)

Essayez-le en ligne!

Une poignée de fonction qui prend "00000000000000000000000000000001"aussi vrai "00000000000000000000000000000000\0"que falsey.

Explication:

Dans Octave, un tableau est considéré comme falsey si au moins un de ses éléments est nul. Le 33e élément de la deuxième chaîne est un caractère avec la valeur ASCII de 0, il peut donc être considéré comme falsey.

Java, 40 caractères, 40 octets

Cela prend la chaîne comme paramètre, ce qui n'est pas correct (la valeur java falsifiée / vraie est forcée par OP pour être représentée par un booléen).

c->{for(int i=0;++i<32;c=0+c);return c;}

Essayez-le en ligne!

Réponse valide: Java, 60 caractères, 60 octets

c->{String k="";for(k+=c?1:0;k.length()<32;k=0+k);return k;}

Essayez-le en ligne!

Je sais qu'il existe déjà une réponse Java qui est plus courte que celle-ci, mais quand même :)

Japt , 13 11 octets

?1:0 ¤i31ç0

Explication:

?1:0 ¤i31ç0
?              // If the input is a truthy, return:
 1             //   1
  :0           //   Else, 0
     ¤         // Convert to a base-2 string
      i        // Insert at index 0:
       31ç0    //   A string filled with 0s, length 31

Enregistré un octet en utilisant une conversion en base 2 intégrée!

Pour insérer la chaîne de 0 devant le 1/ 0, je dois lancer le 1et 0dans une chaîne. La façon typique de le faire serait 1s (3 octets). Mais comme nous ne convertissons que des 1 et des 0, je peux utiliser la base 2 intégrée 1¤(2 octets).

L'entrée peut être sous la forme d'un entier ou d'une chaîne.

0et ""sont fausses dans Japt.

Essayez-le en ligne!

Suite de tests

C # (.NET Core) , 29 octets

a=>new string('0',31)+(a?1:0)

OP dit que 1/0 peut être utilisé pour truey / falsey, donc peut faire aun int et il devient

a=>new string('0',31)+a

C # n'a pas vraiment de vérité / falsey, donc je n'utiliserai pas cette réponse.

Essayez-le en ligne!

MY , 10 9 octets

𝕫BṄiℑpέ←←

Essayez-le en ligne!

Explication (page de code [avec le raisonnement derrière le caractère] / code hexadécimal):

𝕫: 1A - Push an integer from STDIN (lowercase integers)
B: 0B - Push 11 (B is 11 in hex)
Ṅ: 36 - Pop n; push the nth prime, 11th prime is 31 (Ṅ-th)
i: 49 - Pop n; push [1,...,n] (index/iota)
ℑ: 34 - Pop n; push imag(n) (ℑmaginary part, applied to each element, which gives 0 for real numbers)
p: 60 - Pop n; push stringified n (0=>"0" ... 35=>"Z", the b in base upside down)
έ: 56 - Pop n; push n joined by "" (έmpty string)
←: 26 - Pop n; output n with no newline (out←in)
←: 26 - Pop n; output n with no newline (out←in)

Je ne peux pas croire que cela soit possible sans aucune commande à deux arguments!

Edit: enregistré 1 octet en utilisant des nombres premiers au lieu de l'arithmétique pour obtenir 31.

APL, 11 octets

⍕¯32↑1↑1\⍨⊢

Comment?

1\⍨⊢ - répéter 1 fois l'entrée - retourner un tableau vide sur la valeur falsifiée

1↑ - prenez le premier article

¯32↑ - aligner à droite avec 31 zéros

⍕ - format sous forme de chaîne

J, 11 octets

(31#'0'),":

Essayez-le en ligne!

Comment?

31 zeros
00...000  append     turn the 0 or 1 input into string
(31#'0')    ,       ":

note: en J, les booléens sont 0 ou 1, également connu comme "la convention d'iverson", d'après ken iverson, créateur de J et APL