introduzione

Classicamente, i booleani sono un po '; trueo false, 1o 0. Gli zeri iniziali sarebbero semplicemente ridondanti. Ad esempio, 001significa lo stesso 00001o solo1 .

Il booleano a 32 bit

Dato un valore di verità / falsità, emette il valore booleano equivalente a 32 bit come stringa. (O come numero se per qualche motivo la tua lingua supporta zeri iniziali.)

Il tuo programma non deve funzionare per ogni tipo di verità / falsità, ma solo per ciò che il tuo linguaggio di programmazione funziona meglio.

Esempio i / o

Input >> Output

truthy >> 00000000000000000000000000000001
falsey >> 00000000000000000000000000000000

Questo è code-golf , quindi vince il byte più basso!

Python 3 , 33 25 18 15 byte

Grazie @ jurjen-bos per l'informazione __mod__.

'%.32d'.__mod__

Provalo online!

x86-16 Machine Code (DOS), 16 byte

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 funzione precedente riceve un valore booleano (0 == falsey, 1 == truthy) nel BLregistro (byte basso diBX ) e stampa una stringa "booleana ridondante" sull'output standard.

Funziona invocando un interrupt (0x21) per effettuare una chiamata alla funzione DOS (selezionata impostando AHsu 2) che stampa un singolo carattere (inDL ) sull'output standard.

Innanzitutto, il carattere ASCII '0' viene caricato in DL, il contatore ( CX) è impostato su 31 e esegue un ciclo per stampare i byte "ridondanti". Quindi, viene aggiunto il valore booleano di input DL(se BLè false, l'aggiunta di 0 rimarrà DLinvariata come ASCII "0"; se BLè vero,DL verrà incrementato di uno a ASCII '1') e verrà stampato il byte finale.

La funzione non restituisce un valore.

Abbastanza decente per un linguaggio che non fa davvero stringhe.

Programma completo, 21 byte

Se si desidera trasformarlo in un programma completo, sono necessari solo altri 5 byte. Invece di passare l'input in un registro, questo legge l'input dagli argomenti passati sulla riga di comando quando si richiama l'applicazione. Un argomento di 0 viene interpretato come falso, così come la completa mancanza di argomenti; un argomento maggiore di 0 viene interpretato come vero.

È sufficiente assemblare il seguente codice come programma COM, quindi eseguirlo sulla riga di 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

Uscita campione:

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

Come funziona? Bene, è praticamente la stessa cosa, fino a quando non si arriva alle CMPistruzioni. Questo confronta l'argomento della riga di comando con il valore del DLregistro (che, ricordate, contiene uno "0" ASCII). In un programma COM, i byte di codice vengono caricati nell'offset 0x100. Precedentemente si tratta del prefisso del segmento di programma (PSP) , che contiene informazioni sullo stato di un programma DOS. In particolare, all'offset 0x82, si trova il primo argomento (in realtà il secondo, poiché il primo è uno spazio) che è stato specificato sulla riga di comando quando è stato invocato il programma. Quindi, stiamo solo confrontando questo byte con uno "0" ASCII.

Il confronto imposta i flag, quindi l' SALCistruzione (un codice operativo non documentato prima del Pentium, equivalente a sbb al, al, ma solo 1 byte anziché 2) imposta ALsu 0 se i due valori erano uguali o -1 se erano diversi. È quindi ovvio che quando sottraggiamo ALda DL, ciò si traduce in ASCII '0' o '1', a seconda dei casi.

(Nota che, un po 'ironicamente, lo spezzerai se passi un argomento con uno 0 iniziale sulla riga di comando, dato che guarda solo al primo carattere. Quindi 01sarà trattato come un falso. :-)

Python 3 , 23 byte

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

Provalo online!

Javascript, 23 byte

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

!!a costringe a in un booleano, che il plus unario trasforma in un int.

V , 8 byte

32é0Àñl

Provalo online!

Spiegazione:

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 byte

ᛝΨβ_I

Provalo online!

Spiegazione:

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

Salvataggio di un byte grazie a Okx

Ottava , 17 byte

@(n)dec2bin(n,32)

Funzione anonima. Funziona anche con MATLAB.

Provalo online!

ArnoldC , 369 byte

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

Provalo online!

Brainfuck , 61 60 36 byte

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

Sono sicuro che esiste un modo intelligente di non muoversi così tanto con i puntatori.

Avevo ragione. C'erano. Grazie a @Graviton per avermi dato l'idea!

Passaggio successivo: ottieni i valori 32 e 48 più velocemente!

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

È stato divertente per un primo golf!

Adesso è arrivato troppo tardi. Cosa sto persino facendo

Scala, 32 byte

Scusa ma sono stato costretto a farlo in 32 byte> _ <

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

È racchiuso da una funzione che prende tcome parametro (come uno stringche può essere "0" o "1" per resp. Falso o verità), e sviene restituito.

Provalo online!

Risposta valida: Scala, 46 byte

Come per la mia risposta Java, dovevo prendere un valore booleano per il parametro. Così :

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

Provalo online!

Braingolf , 10 8 byte

#␟>[0_]N

Provalo online!

␟è un separatore di unità, ASCII 0x1Fo 31. Non riesco a trovare il carattere effettivamente da incollare in TIO, quindi TIO invece usa # 1-, che spinge lo spazio (32) e diminuisce a 31.

Spiegazione

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

Ottava , 23 byte

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

Provalo online!

Questo è più breve di tutti gli approcci con cui ho provato printf. Potrei essermi perso qualcosa, dal momento che l'ho fatto sul mio telefono.

Solo un byte in più

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

Questo potrebbe essere 18 byte se potessi prendere 1/0 come stringhe.

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

Provalo online!

Java 8, 31 27 byte

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

-4 byte grazie a @ OlivierGrégoire .

Provalo qui.

05AB1E , 5 byte

¾31׫

Provalo online!

Rubino, 21 byte

Sì, quello spazio deve essere lì ..: /

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

In Ruby tutto tranne falseed nilè vero; Provalo online!

Mathematica, 36 byte

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

Mathematica, 26 byte

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

Provalo online!

Carbone , 5 byte

×0³¹Ｓ

Provalo online! (Link alla versione dettagliata.)

Come Charcoal capisce 0e 1come Trueo False, questo stampa solo 31 se 0l'input ( 0o 1) come stringa.

Python 2 , 26 25 byte

Grazie a Erik the Outgolfer per aver salvato un byte!

Va per l'approccio del programma completo:

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

Provalo online!

Non voluto, non necessario, opportunistico , 7 byte

P0M31P*

Passare 1 o 0 nel registro.

C, 26 byte

Praticamente la stessa idea della soluzione di 1bluestone , ma in C è più breve e funziona correttamente per qualsiasi input intero:

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

Naturalmente, questo include alcune variabili / funzioni tipizzate in modo implicito come fanno tutte le buone risposte C-golf ... L' !!operatore è il modo più breve per convertire qualsiasi valore di verità in 1in C (tramite doppia negazione, !è definito per restituire 1o0 ).

Prova 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 byte

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

Provalo online!

Grazie @nimi per i -5byte!

PHP, 28 byte

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

Salva come bool.php ed esegui:

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

Ly , 20 15 13 byte

65*1+[0u1-]nu

EDIT: salvato 5 byte grazie a ovs.
EDIT: salvato altri 2 byte stampando 0 come numero anziché come carattere.

Ottava, 16 11 byte

@(x)x(1:32)

Provalo online!

Una maniglia di funzione che assume "00000000000000000000000000000001"come verità e "00000000000000000000000000000000\0"falsità.

Spiegazione:

In Octave un array è considerato falso se almeno uno dei suoi elementi è zero. Il 33 ° elemento della seconda stringa è un carattere con il valore ASCII pari a 0, quindi può essere considerato falso.

Java, 40 caratteri, 40 byte

Questo prende la stringa come parametro, il che non è corretto (il valore java falsy / truthy è costretto da OP a essere rappresentato da un valore booleano).

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

Provalo online!

Risposta valida: Java, 60 caratteri, 60 byte

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

Provalo online!

So che esiste già una risposta Java più corta di questa, ma comunque :)

Japt , 13 11 byte

?1:0 ¤i31ç0

Spiegazione:

?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

Hai salvato un byte usando una conversione base-2 integrata!

Per inserire la stringa di 0 davanti a 1/ 0, devo eseguire il cast di 1e 0in una stringa. Il modo tipico di farlo sarebbe 1s (3 byte). Ma poiché stiamo solo convertendo 1 e 0, posso usare il built-in base-2 1¤(2 byte).

L'input può avere la forma di un numero intero o di una stringa.

0 e "" sono falsi in Japt.

Provalo online!

Suite di test

C # (.NET Core) , 29 byte

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

OP ha detto che 1/0 può essere usato per verità / falsità, quindi può fare aun int e diventa

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

C # non ha davvero verità / falsità, quindi non userò questa risposta.

Provalo online!

MY , 10 9 byte

𝕫BṄiℑpέ←←

Provalo online!

Spiegazione (codepage [con ragionamento dietro il carattere] / codice esadecimale):

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

Non posso credere che ciò sia possibile senza alcun comando a due argomenti!

Modifica: salvato 1 byte utilizzando i numeri primi anziché l'aritmetica per ottenere 31.

APL, 11 byte

⍕¯32↑1↑1\⍨⊢

Come?

1\⍨⊢ - ripetere 1 volte di input - restituisce un array vuoto sul valore errato

1↑ - prendi il primo oggetto

¯32↑ - Allinea a destra con 31 zeri

⍕ - formatta come stringa

J, 11 byte

(31#'0'),":

Provalo online!

Come?

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

nota: in J, i booleani sono 0 o 1, noto anche come "convenzione iverson", dopo ken iverson, creatore di J e APL