Introducción

Clásicamente, los booleanos son un bit; trueo false, 1o 0. Los ceros a la izquierda serían redundantes. Por ejemplo, 001significa lo mismo que 00001o simplemente 1.

El booleano de 32 bits

Dado un valor verdadero / falso, genera el booleano equivalente de 32 bits como una cadena. (O como un número si, por alguna razón, su idioma admite ceros a la izquierda).

Su programa no tiene que funcionar para todos los tipos de verdad / falsedad, solo para lo que su lenguaje de programación funciona mejor.

Ejemplo de E / S

Input >> Output

truthy >> 00000000000000000000000000000001
falsey >> 00000000000000000000000000000000

Este es el código de golf , por lo que gana los bytes más bajos.

Python 3 , 33 25 18 15 bytes

Gracias @ jurjen-bos por el __mod__consejo.

'%.32d'.__mod__

Pruébalo en línea!

Código de máquina x86-16 (DOS), 16 bytes

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 función anterior recibe un valor booleano (0 == falsey, 1 == verdad) en el BLregistro (byte bajo de BX) e imprime una cadena "booleana redundante" en la salida estándar.

Funciona invocando una interrupción (0x21) para realizar una llamada a la función de DOS (seleccionada mediante la configuración AHde 2) que imprime un solo carácter (entrada DL) en la salida estándar.

Primero, se carga el carácter ASCII '0' DL, el contador ( CX) se establece en 31 y se repite para imprimir los bytes "redundantes". Luego, el valor booleano de entrada se agrega a DL(si BLes falsey, agregar 0 dejará DLsin cambios como ASCII '0'; si BLes verdadero, DLse incrementará en uno a ASCII '1'), y se imprimirá el byte final.

La función no devuelve un valor.

Bastante decente para un lenguaje que realmente no hace cadenas.

Programa completo, 21 bytes

Si desea convertirlo en un programa completo, solo se requieren 5 bytes más. En lugar de pasar la entrada en un registro, esto lee la entrada de los argumentos pasados ​​en la línea de comando al invocar la aplicación. Un argumento de 0 se interpreta como falsey, como lo es la falta total de argumentos; Un argumento mayor que 0 se interpreta como verdadero.

Simplemente ensamble el siguiente código como un programa COM y luego ejecútelo en la línea de comando.

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

Salida de muestra:

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

¿Como funciona? Bueno, es básicamente lo mismo, hasta llegar a las CMPinstrucciones. Esto compara el argumento de la línea de comandos con el valor del DLregistro (que, recuerda, contiene un ASCII '0'). En un programa COM, los bytes de código se cargan en el desplazamiento 0x100. Precedente es el prefijo de segmento de programa (PSP) , que contiene información sobre el estado de un programa DOS. Específicamente, en el desplazamiento 0x82, se encuentra el primer argumento (en realidad el segundo, ya que el primero es un espacio) que se especificó en la línea de comando cuando se invocó el programa. Entonces, solo estamos comparando este byte con un ASCII '0'.

La comparación establece los indicadores, y luego la SALCinstrucción (un código de operación no documentado antes del Pentium, equivalente a sbb al, al, pero solo 1 byte en lugar de 2) se establece ALen 0 si los dos valores eran iguales, o -1 si eran diferentes. Es entonces evidente que cuando se resta ALde DL, esto resulta en ASCII '0' o '1', según el caso.

(Tenga en cuenta que, irónicamente, lo romperá si pasa un argumento con un 0 01inicial en la línea de comando, ya que solo se ve en el primer carácter. Por lo tanto , se tratará como falsey. :-)

Python 3 , 23 bytes

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

Pruébalo en línea!

Javascript, 23 bytes

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

!!a coacciona a en booleano, que el plus unario se convierte en int.

V , 8 bytes

32é0Àñl

Pruébalo en línea!

Explicación:

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 bytes

ᛝΨβ_I

Pruébalo en línea!

Explicación:

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

Guardado un byte gracias a Okx

Octava , 17 bytes

@(n)dec2bin(n,32)

Función anónima. Funciona en MATLAB también.

Pruébalo en línea!

ArnoldC , 369 bytes

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

Pruébalo en línea!

Brainfuck , 61 60 36 bytes

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

Estoy seguro de que hay una forma inteligente de no moverse tanto con los punteros.

Yo tenía razón. Había. ¡Gracias a @Graviton por darme la idea!

Siguiente paso: ¡Obtenga los valores 32 y 48 más rápido!

Pruébalo en línea!

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

Fue divertido para un primer golf!

Ha llegado demasiado tarde ahora. ¿Qué estoy haciendo?

Scala, 32 bytes

Lo siento, pero me vi obligado a hacerlo en 32 bytes> _ <

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

Está encerrado por una función que toma tcomo parámetro (como un stringque puede ser "0" o "1" para resp. Falsedad o verdad), y sse devuelve.

¡Pruébelo en línea!

Respuesta válida: Scala, 46 bytes.

Igual que mi respuesta de Java, se suponía que debía tomar un valor booleano para el parámetro. Entonces :

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

¡Pruébelo en línea!

Braingolf , 10 8 bytes

#␟>[0_]N

Pruébalo en línea!

␟es un separador de unidad, ASCII 0x1Fo 31. No se puede encontrar el carácter real para pegar en TIO, por lo que TIO en su lugar usa # 1-, lo que empuja el espacio (32) y disminuye a 31.

Explicación

#␟>[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

Octava , 23 bytes

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

Pruébalo en línea!

Esto es más corto que todos los enfoques que probé printf. Sin embargo, podría haber perdido algo, ya que hice esto en mi teléfono.

Solo un byte más

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

Esto podría ser 18 bytes si pudiera tomar 1/0 como cadenas.

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

Pruébalo en línea!

Java 8, 31 27 bytes

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

-4 bytes gracias a @ OlivierGrégoire .

Pruébalo aquí

05AB1E , 5 bytes

¾31׫

Pruébalo en línea!

Ruby, 21 bytes

Sí, ese espacio necesita estar allí ...: /

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

En Ruby todo excepto falsey niles verdad; Pruébalo en línea!

Mathematica, 36 bytes

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

Mathematica, 26 bytes

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

Pruébalo en línea!

Carbón de leña , 5 bytes

×0³¹Ｓ

Pruébalo en línea! (Enlace a la versión detallada).

Como Charcoal entiende 0y 1como Trueo False, esto solo imprime 31 0sy la entrada ( 0o 1) como una cadena.

Python 2 , 26 25 bytes

¡Gracias a Erik the Outgolfer por guardar un byte!

Va por el enfoque del programa completo:

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

Pruébalo en línea!

No deseado, innecesario, oportunista , 7 bytes

P0M31P*

Pase 1 o 0 en el registro.

C, 26 bytes

Prácticamente la misma idea que la solución de 1bluestone , pero en C es más corta y funciona correctamente para cualquier entrada entera:

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

Por supuesto, esto incluye algunas variables / funciones escritas implícitamente como lo hacen todas las buenas respuestas de C-golf ... El !!operador es la forma más corta de convertir cualquier valor verdadero 1en C (a través de la negación doble, !se define para devolver 1o0 ).

Prueba con:

#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 bytes

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

Pruébalo en línea!

Gracias @nimi por -5bytes!

PHP, 28 bytes

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

Guardar como bool.php y ejecutar:

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

Ly , 20 15 13 bytes

65*1+[0u1-]nu

EDITAR: Guardado 5 bytes gracias a los ovs.
EDITAR: guardó otros 2 bytes imprimiendo 0 como un número en lugar de un carácter.

Octava, 16 11 bytes

@(x)x(1:32)

Pruébalo en línea!

Una función de manejo que toma "00000000000000000000000000000001"como veraz y "00000000000000000000000000000000\0"falsey.

Explicación:

En Octave, una matriz se considera falsey si al menos uno de sus elementos es cero. El elemento 33 de la segunda cadena es un carácter con el valor ASCII de 0, por lo que puede considerarse como falsey.

Java, 40 caracteres, 40 bytes

Esto toma una cadena como parámetro, que no es correcto (el valor de Java falso / verdadero es forzado por OP a ser representado por un booleano).

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

¡Pruébelo en línea!

Respuesta válida: Java, 60 caracteres, 60 bytes.

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

¡Pruébelo en línea!

Sé que ya hay una respuesta Java que es más corta que esta, pero aún así :)

Japt , 13 11 bytes

?1:0 ¤i31ç0

Explicación:

?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

¡Guardado un byte usando una conversión de base 2 incorporada!

Para insertar la cadena de 0s delante de 1/ 0, necesito convertir el 1y 0en una cadena. La forma típica de hacerlo sería 1s (3 bytes). Pero debido a que solo estamos convirtiendo 1s y 0s, puedo usar la base-2 incorporada 1¤(2 bytes).

La entrada puede tener la forma de un entero o una cadena.

0y ""son falsas en Japt.

Pruébalo en línea!

Banco de pruebas

C # (.NET Core) , 29 bytes

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

OP dijo que 1/0 se puede usar para verdadero / falso, por lo que puede hacer a un int y se convierte

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

Sin embargo, C # realmente no tiene verdadero / falso así que no usaré esta respuesta.

Pruébalo en línea!

MI , 10 9 bytes

𝕫BṄiℑpέ←←

Pruébalo en línea!

Explicación (página de códigos [con razonamiento detrás del carácter] / código hexadecimal):

𝕫: 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)

¡No puedo creer que esto sea posible sin ningún comando de dos argumentos!

Editar: guardado 1 byte usando primos en lugar de aritmética para obtener 31.

APL, 11 bytes

⍕¯32↑1↑1\⍨⊢

¿Cómo?

1\⍨⊢ - repita 1 veces de entrada - devuelva una matriz vacía en valor falso

1↑ - toma el primer artículo

¯32↑ - alinear a la derecha con 31 ceros

⍕ - formatear como cadena

J, 11 bytes

(31#'0'),":

Pruébalo en línea!

¿cómo?

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

nota: en J, los booleanos son 0 o 1, también conocido como "la convención de iverson", después de ken iverson, creador de J y APL