Einführung

Klassischerweise sind Boolesche Werte ein Bit. trueoder false, 1oder 0. Führende Nullen wären einfach überflüssig. Zum Beispiel 001bedeutet das gleiche wie 00001oder nur 1.

Der 32-Bit-Boolesche Wert

Wenn Sie einen Wert für "truthy / falsey" angeben, geben Sie den entsprechenden 32-Bit-Booleschen Wert als Zeichenfolge aus. (Oder als Zahl, wenn Ihre Sprache aus irgendeinem Grund führende Nullen unterstützt.)

Ihr Programm muss nicht für jeden Wahrheits- / Falschtyp geeignet sein, sondern nur für das, wofür Ihre Programmiersprache am besten geeignet ist.

Beispiel I / O

Input >> Output

truthy >> 00000000000000000000000000000001
falsey >> 00000000000000000000000000000000

Das ist Code-Golf , also gewinnt das niedrigste Byte!

Python 3 , 33 25 18 15 Bytes

Danke @ jurjen-bos für den __mod__Tipp.

'%.32d'.__mod__

Probieren Sie es online!

x86-16-Computercode (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

Die obige Funktion empfängt einen Booleschen Wert (0 == Falsey, 1 == Truthy) im BLRegister (Low-Byte von BX) und gibt einen "redundanten Booleschen" String an die Standardausgabe aus.

Es funktioniert durch Aufrufen eines Interrupts (0x21), um einen DOS-Funktionsaufruf (ausgewählt durch Setzen AHauf 2) auszuführen, der ein einzelnes Zeichen (in DL) an die Standardausgabe ausgibt.

Zuerst wird das ASCII-Zeichen '0' geladen DL, der Zähler ( CX) wird auf 31 gesetzt und es wird eine Schleife ausgeführt, um die "redundanten" Bytes zu drucken. Dann wird der boolesche Eingabewert addiert DL(wenn BLfalsch ist, bleibt das Addieren von 0 DLunverändert als ASCII '0'; wenn BLwahr, DLwird es um eins zu ASCII '1' inkrementiert), und das letzte Byte wird gedruckt.

Die Funktion gibt keinen Wert zurück.

Ziemlich anständig für eine Sprache, die nicht wirklich Streicher ist.

Volles Programm, 21 Bytes

Wenn Sie ein vollständiges Programm erstellen möchten, sind nur noch 5 Bytes erforderlich. Anstatt die Eingabe in ein Register zu übergeben, wird die Eingabe aus den Argumenten gelesen, die beim Aufrufen der Anwendung in der Befehlszeile übergeben wurden. Ein Argument von 0 wird ebenso wie das völlige Fehlen von Argumenten als falsch interpretiert. Ein Argument größer als 0 wird als wahr interpretiert.

Stellen Sie einfach den folgenden Code als COM-Programm zusammen und führen Sie ihn dann in der Befehlszeile aus.

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

Beispielausgabe:

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

Wie funktioniert es? Nun, es ist im Grunde dasselbe, bis Sie zur CMPAnweisung kommen. Dadurch wird das Befehlszeilenargument mit dem Wert des DLRegisters verglichen (das, wie Sie sich erinnern, eine ASCII-0 enthält). In einem COM-Programm werden die Codebytes mit dem Offset 0x100 geladen. Davor steht das Programmsegment-Präfix (PSP) , das Informationen zum Status eines DOS-Programms enthält. Insbesondere finden Sie bei Offset 0x82 das erste (eigentlich das zweite, da das erste ein Leerzeichen ist) Argument, das in der Befehlszeile angegeben wurde, als das Programm aufgerufen wurde. Wir vergleichen dieses Byte also nur mit einer ASCII-0.

Beim Vergleich werden die Flags gesetzt, und dann wird der SALCBefehl (ein undokumentierter Opcode vor dem Pentium, der sbb al, alnur 1 Byte anstelle von 2 entspricht) ALauf 0 gesetzt, wenn die beiden Werte gleich waren, oder auf -1, wenn sie unterschiedlich waren. Es ist dann klar , dass , wenn wir subtrahieren ALaus DL, ergibt sich daraus entweder ASCII ‚0‘ oder ‚1‘, als angemessen.

(Beachte, dass du es ironischerweise kaputt machst, wenn du ein Argument mit einer führenden 0 in der Kommandozeile 01übergibst , da es nur auf das erste Zeichen abzielt. Also wird es als falsch behandelt. :-)

Python 3 , 23 Bytes

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

Probieren Sie es online!

Javascript, 23 Bytes

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

!!a zwingt a zu einem Booleschen Wert, aus dem das unäre Plus ein int wird.

V , 8 Bytes

32é0Àñl

Probieren Sie es online!

Erläuterung:

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

Probieren Sie es online!

Erläuterung:

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

Dank Okx wurde ein Byte gespeichert

Oktave , 17 Bytes

@(n)dec2bin(n,32)

Anonyme Funktion. Funktioniert auch in MATLAB.

Probieren Sie es 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

Probieren Sie es online!

Brainfuck , 61 60 36 Bytes

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

Ich bin sicher, es gibt eine clevere Möglichkeit, sich mit den Zeigern nicht so viel zu bewegen.

Ich lag richtig. Dort gab es. Vielen Dank an @Graviton für die Idee!

Nächster Schritt: Holen Sie sich die Werte 32 und 48 schneller!

Probieren Sie es 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.

Hat Spaß gemacht für einen ersten Golf!

Es ist viel zu spät geworden. Was mache ich überhaupt?

Scala, 32 Bytes

Sorry, aber ich musste es in 32 Bytes> _ <tun

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

Es wird von einer Funktion eingeschlossen, die tals Parameter verwendet wird (als string"0" oder "1" für bzw. falsch oder wahr) und szurückgegeben.

Probieren Sie es online!

Gültige Antwort: Scala, 46 Bytes

Genau wie meine Java-Antwort sollte ich einen Booleschen Wert für den Parameter verwenden. So :

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

Probieren Sie es online!

Braingolf , 10 8 Bytes

#␟>[0_]N

Probieren Sie es online!

␟ist ein Unit Separator, ASCII 0x1Foder 31. Kann das tatsächliche Zeichen nicht finden, das in TIO eingefügt werden soll, daher verwendet TIO stattdessen # 1-das Leerzeichen (32) und dekrementiert es auf 31.

Erläuterung

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

Oktave , 23 Bytes

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

Probieren Sie es online!

Dies ist kürzer als alle Ansätze, mit denen ich versucht habe printf. Möglicherweise habe ich jedoch etwas verpasst, da ich dies auf meinem Telefon getan habe.

Nur noch ein Byte länger

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

Das könnten 18 Bytes sein, wenn ich 1/0 als Zeichenkette nehmen könnte.

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

Probieren Sie es online!

Java 8, 31 27 Bytes

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

-4 Bytes dank @ OlivierGrégoire .

Probieren Sie es hier aus.

05AB1E , 5 Bytes

¾31׫

Probieren Sie es online!

Ruby, 21 Bytes

Ja, dieser Raum muss da sein ..: /

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

In Ruby ist alles außer falseund nilwahr; Probieren Sie es online!

Mathematica, 36 Bytes

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

Mathematica, 26 Bytes

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

Probieren Sie es online!

Kohle , 5 Bytes

×0³¹Ｓ

Probieren Sie es online! (Link zur ausführlichen Version.)

Nach dem Verständnis von Charcoal 0und 1als Trueoder Falsegibt dies nur 31 0s und die Eingabe ( 0oder 1) als Zeichenfolge aus.

Python 2 , 26 25 Bytes

Vielen Dank an Erik den Outgolfer für das Speichern eines Bytes!

Entscheidet sich für den vollständigen Programmansatz:

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

Probieren Sie es online!

Unerwünscht, unnötig, opportunistisch , 7 Bytes

P0M31P*

Geben Sie entweder 1 oder 0 in das Register ein.

C 26 Bytes

Ziemlich die gleiche Idee wie die Lösung von 1bluestone , aber in C ist sie kürzer und funktioniert bei jeder Ganzzahleingabe korrekt:

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

Dies schließt natürlich einige implizit eingegebene Variablen / Funktionen ein, wie dies bei allen guten C-Golf-Antworten !!der Fall ist ... Der Operator ist der kürzeste Weg, um einen Wahrheitswert 1in C umzuwandeln (über doppelte Negation !wird definiert, ob er entweder 1oder zurückgibt 0).

Testen Sie mit:

#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

Probieren Sie es online!

Danke @nimi für -5Bytes!

PHP, 28 Bytes

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

Als bool.php speichern und ausführen:

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

Ly , 20 15 13 Bytes

65*1+[0u1-]nu

BEARBEITEN: 5 Bytes dank ovs gespeichert.
BEARBEITEN: Speichert weitere 2 Bytes, indem 0 als Zahl und nicht als Zeichen gedruckt wird.

Oktave, 16 11 Bytes

@(x)x(1:32)

Probieren Sie es online!

Ein Funktionshandle, das "00000000000000000000000000000001"als wahr und "00000000000000000000000000000000\0"als falsch gilt.

Erläuterung:

In Octave wird ein Array als falsch betrachtet, wenn mindestens eines seiner Elemente Null ist. Das 33. Element der zweiten Zeichenfolge ist ein Zeichen mit dem ASCII-Wert 0, sodass es als falsch betrachtet werden kann.

Java, 40 Zeichen, 40 Bytes

Als Parameter wird ein String verwendet, der nicht korrekt ist (der Java-Wert falsy / truthy wird von OP gezwungen, durch einen Booleschen Wert dargestellt zu werden).

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

Probieren Sie es online!

Gültige Antwort: Java, 60 Zeichen, 60 Byte

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

Probieren Sie es online!

Ich weiß, dass es bereits eine Java-Antwort gibt, die kürzer ist als diese, aber immer noch :)

Japt , 13 11 Bytes

?1:0 ¤i31ç0

Erläuterung:

?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

Ein Byte mit einer integrierten Base-2-Konvertierung gespeichert!

Um die Zeichenfolge von 0s vor dem 1/ einzufügen 0, muss das 1und 0in eine Zeichenfolge umgewandelt werden. Die typische Vorgehensweise wäre 1s (3 Bytes). Da wir jedoch nur Einsen und Nullen konvertieren, kann ich die integrierte Basis 2 1¤(2 Byte) verwenden.

Die Eingabe kann in Form einer Ganzzahl oder einer Zeichenfolge erfolgen.

0und ""sind falsch in Japt.

Probieren Sie es online!

Testsuite

C # (.NET Core) , 29 Byte

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

OP sagte 1/0 kann für Truthy / Falsey verwendet werden, kann also aein Int machen und es wird

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

C # hat zwar nicht wirklich Wahrhaftigkeit / Falschheit, daher werde ich diese Antwort nicht verwenden.

Probieren Sie es online!

MEIN , 10 9 Bytes

𝕫BṄiℑpέ←←

Probieren Sie es online!

Erklärung (Codepage [mit Begründung hinter dem Zeichen] / Hex-Code):

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

Ich kann nicht glauben, dass dies ohne irgendwelche Befehle mit zwei Argumenten möglich ist!

Bearbeiten: 1 Byte gespeichert, indem Primzahlen anstelle von Arithmetik verwendet werden, um 31 zu erhalten.

APL, 11 Bytes

⍕¯32↑1↑1\⍨⊢

Wie?

1\⍨⊢ - 1 Eingabe wiederholen - leeres Array bei falschem Wert zurückgeben

1↑ - Nimm den ersten Gegenstand

¯32↑ - Mit 31 Nullen rechts ausrichten

⍕ - Format als Zeichenfolge

J, 11 Bytes

(31#'0'),":

Probieren Sie es online!

Wie?

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

Anmerkung: In J sind Boolesche Werte 0 oder 1, auch als "Iverson-Konvention" bekannt, nach Ken Iverson, dem Schöpfer von J und APL