Introdução

Classicamente, os booleanos são um pouco; trueou false, 1ou 0. Os zeros à esquerda seriam redundantes. Por exemplo, 001significa o mesmo 00001ou apenas 1.

O booleano de 32 bits

Dado um valor truthy / falsey, emita o booleano de 32 bits equivalente como uma string. (Ou como um número, se por algum motivo seu idioma suportar zeros à esquerda.)

Seu programa não precisa funcionar para todos os tipos de verdade / falsidade, apenas para o que sua linguagem de programação funciona melhor.

Exemplo de E / S

Input >> Output

truthy >> 00000000000000000000000000000001
falsey >> 00000000000000000000000000000000

Isso é código-golfe , então os bytes mais baixos vencem!

Python 3 , 33 25 18 15 bytes

Obrigado @ jurjen-bos pela __mod__dica.

'%.32d'.__mod__

Experimente online!

x86-16 Código da Máquina (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

A função acima recebe um valor booleano (0 == falsey, 1 == truthy) no BLregistro (byte baixo de BX) e imprime uma string "booleana redundante" na saída padrão.

Ele funciona chamando uma interrupção (0x21) para fazer uma chamada de função do DOS (selecionada pela configuração AH2) que imprime um único caractere (in DL) na saída padrão.

Primeiro, o caractere ASCII '0' é carregado DL, o contador ( CX) é definido como 31 e faz um loop para imprimir os bytes "redundantes". Em seguida, o valor booleano de entrada é adicionado a DL(se BLfor falsey, adicionar 0 DLpermanecerá inalterado como ASCII '0'; se BLfor verdade, DLserá incrementado em um para ASCII '1') e o byte final será impresso.

A função não retorna um valor.

Bastante decente para uma linguagem que realmente não faz cordas.

Programa completo, 21 bytes

Se você deseja transformá-lo em um programa completo, são necessários apenas mais 5 bytes. Em vez de passar a entrada em um registro, ela lê a entrada dos argumentos transmitidos na linha de comando ao invocar o aplicativo. Um argumento de 0 é interpretado como falsey, assim como a completa falta de argumentos; um argumento maior que 0 é interpretado como verdade.

Simplesmente monte o código a seguir como um programa COM e execute-o na linha 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

Saída de amostra:

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? Bem, é basicamente a mesma coisa, até você chegar às CMPinstruções. Isso compara o argumento da linha de comando com o valor do DLregistrador (que você se lembra, contém um ASCII '0'). Em um programa COM, os bytes de código são carregados no deslocamento 0x100. O precedente é o prefixo do segmento de programa (PSP) , que contém informações sobre o estado de um programa DOS. Especificamente, no deslocamento 0x82, você encontra o primeiro argumento (na verdade o segundo, já que o primeiro é um espaço) que foi especificado na linha de comando quando o programa foi chamado. Então, estamos apenas comparando esse byte com um ASCII '0'.

A comparação define os sinalizadores e, em seguida, a SALCinstrução (um código de operação não documentado anterior ao Pentium, equivalente a sbb al, al, mas apenas 1 byte em vez de 2) define ALcomo 0 se os dois valores forem iguais ou -1 se forem diferentes. Em seguida, é óbvio que, quando nós subtraímos ALa partir DL, isso resulta em ASCII '0' ou '1', conforme o caso.

(Observe que, ironicamente, você o quebrará se passar um argumento com um 0 à esquerda na linha de comando, pois ele olha apenas para o primeiro caractere. Portanto 01, será tratado como falsey. :-)

Python 3 , 23 bytes

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

Experimente online!

Javascript, 23 bytes

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

!!a coage a em um booleano, que o plus unário se transforma em um int.

V , 8 bytes

32é0Àñl

Experimente online!

Explicação:

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

Experimente online!

Explicação:

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

Guardou um byte graças a Okx

Oitava , 17 bytes

@(n)dec2bin(n,32)

Função anônima. Também trabalha em MATLAB.

Experimente online!

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

Experimente online!

Brainfuck , 61 60 36 bytes

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

Tenho certeza de que existe uma maneira inteligente de não se mexer tanto com os ponteiros.

Eu tinha razão. Havia. Obrigado a @Graviton por me dar a ideia!

Próxima etapa: obtenha os valores 32 e 48 mais rapidamente!

Experimente online!

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

Foi divertido para um primeiro golfe!

Chegou tarde demais agora. O que eu estou fazendo?

Scala, 32 bytes

Desculpe, mas fui forçado a fazê-lo em 32 bytes> _ <

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

É delimitada por uma função que assume tcomo parâmetro (como um stringque pode ser "0" ou "1" para resp. Falsy ou truthy) es é retornado.

Experimente Online!

Resposta válida: Scala, 46 bytes

Igual à minha resposta java, eu deveria usar um booleano para o parâmetro Então :

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

Experimente Online!

Braingolf , 10 8 bytes

#␟>[0_]N

Experimente online!

␟é um separador de unidade, ASCII 0x1Fou 31. Não é possível encontrar o caractere realmente para colar no TIO; portanto, o TIO usa# 1- , o que empurra o espaço (32) e diminui para 31.

Explicação

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

Oitava , 23 bytes

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

Experimente online!

Isso é mais curto do que todas as abordagens que tentei printf. Talvez eu tenha perdido alguma coisa, desde que fiz isso no meu telefone.

Apenas um byte a mais

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

Isso poderia ter 18 bytes se eu pudesse usar 1/0 como seqüências de caracteres.

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

Experimente online!

Java 8, 31 27 bytes

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

-4 bytes graças a @ OlivierGrégoire .

Experimente aqui.

05AB1E , 5 bytes

¾31׫

Experimente online!

Ruby, 21 bytes

Sim, esse espaço precisa estar lá ..: /

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

Em Ruby, tudo, exceto falsee nilé verdadeiro; Experimente online!

Mathematica, 36 bytes

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

Mathematica, 26 bytes

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

Experimente online!

Carvão , 5 bytes

×0³¹Ｓ

Experimente online! (Link para a versão detalhada.)

Como o Charcoal entende 0e 1como Trueou False, isso apenas imprime 31 se 0a entrada ( 0ou 1) como sequência.

Python 2 , 26 25 bytes

Obrigado a Erik, o Outgolfer, por salvar um byte!

Vai para a abordagem completa do programa:

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

Experimente online!

Indesejável, desnecessário, oportunista , 7 bytes

P0M31P*

Passe 1 ou 0 para o registro.

C, 26 bytes

Praticamente a mesma idéia que a solução da 1bluestone , mas em C é mais curta e funciona corretamente para qualquer entrada inteira:

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

Obviamente, isso inclui algumas variáveis ​​/ funções de tipo implícito, como todas as boas respostas C-golf ... O !!operador é a maneira mais curta de converter qualquer valor verdadeiro 1em C (via dupla negação, !é definido para retornar 1ou0 ).

Teste com:

#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

Experimente online!

Obrigado @nimi pelos -5bytes!

PHP, 28 bytes

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

Salve como bool.php e execute:

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

Ly , 20 15 13 bytes

65*1+[0u1-]nu

EDIT: Salvo 5 bytes graças a ovs.
EDIT: Salva outros 2 bytes imprimindo 0 como um número e não como um caractere.

Oitava, 16 11 bytes

@(x)x(1:32)

Experimente online!

Um identificador de função que leva "00000000000000000000000000000001"como verdade e "00000000000000000000000000000000\0"como falsey.

Explicação:

Na oitava, uma matriz é considerada falsey se pelo menos um de seus elementos for zero. O 33º elemento da segunda string é um caractere com o valor ASCII de 0, para que possa ser considerado como falsey.

Java, 40 caracteres, 40 bytes

Isso usa string como parâmetro, o que não está correto (o valor java falsy / truthy é forçado pelo OP a ser representado por um booleano).

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

Experimente Online!

Resposta válida: Java, 60 caracteres, 60 bytes

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

Experimente Online!

Eu sei que já existe uma resposta Java que é mais curta que esta, mas ainda :)

Japonês , 13 11 bytes

?1:0 ¤i31ç0

Explicação:

?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

Salvou um byte usando uma conversão de base 2 integrada!

Para inserir a sequência de 0s na frente do 1/ 0, preciso converter a sequência 1e 0em uma sequência. A maneira típica de fazer isso seria 1s (3 bytes). Mas, como estamos convertendo apenas 1s e 0s, posso usar a base 2 integrada 1¤(2 bytes).

A entrada pode estar na forma de um número inteiro ou sequência.

0e ""são falsas em Japt.

Experimente online!

Suíte de teste

C # (.NET Core) , 29 bytes

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

O OP disse que 1/0 pode ser usado para truthy / falsey, então pode fazer aum int e torna-se

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

C # realmente não tem truthy / falsey, então não usarei esta resposta.

Experimente online!

MY , 10 9 bytes

𝕫BṄiℑpέ←←

Experimente online!

Explicação (página de códigos [com raciocínio por trás do caractere] / 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)

Não acredito que isso seja possível sem nenhum comando de dois argumentos!

Editar: economizou 1 byte usando números primos em vez de aritmético para obter 31.

APL, 11 bytes

⍕¯32↑1↑1\⍨⊢

Quão?

1\⍨⊢ - repetir 1 vezes de entrada - retornar matriz vazia com valor falso

1↑ - pegue o primeiro item

¯32↑ - alinhar à direita com 31 zeros

⍕ - formato como string

J, 11 bytes

(31#'0'),":

Experimente online!

como?

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

nota: em J, os booleanos são 0 ou 1, também conhecido como "a convenção iverson", depois de ken iverson, criador de J e APL