Wprowadzenie

Klasycznie booleany mają jeden bit; truealbo false, 1albo 0. Zera wiodące byłyby po prostu zbędne. Na przykład 001oznacza to samo co 00001lub tylko 1.

32-bitowa wartość logiczna

Biorąc pod uwagę wartość true / falsey, wypisuje ekwiwalent 32-bitowej wartości logicznej jako ciąg. (Lub jako liczba, jeśli dla jakiegoś powodu twój język obsługuje wiodące zera).

Twój program nie musi działać na każdy typ prawdy / fałszu, tylko na to, na co najlepiej działa Twój język programowania.

Przykład we / wy

Input >> Output

truthy >> 00000000000000000000000000000001
falsey >> 00000000000000000000000000000000

To jest golf golfowy , więc wygrywa najmniej bajtów!

Python 3 , 33 25 18 15 bajtów

Dzięki @ jurjen-bos za __mod__wskazówkę.

'%.32d'.__mod__

Wypróbuj online!

x86-16 Kod maszynowy (DOS), 16 bajtów

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

Powyższa funkcja otrzymuje w BLrejestrze wartość logiczną (0 == falsey, 1 == prawda) BXi wypisuje na standardowym wyjściu ciąg znaków „redundantny”.

Działa poprzez wywołanie przerwania (0x21), aby wykonać wywołanie funkcji DOS (wybrane przez ustawienie AHna 2), które wypisuje pojedynczy znak (wDL ) na standardowe wyjście.

Najpierw ładowany jest znak ASCII „0” DL, licznik ( CX) jest ustawiony na 31 i zapętla się, aby wydrukować „nadmiarowe” bajty. Następnie dodawana jest wartość logiczna wejściowa DL(jeśli BLjest falsey, dodanie 0 pozostawi DLniezmienioną jako ASCII „0”; jeśli BLjest prawdą, DLzostanie zwiększone o jeden do ASCII „1”), i zostanie wydrukowany ostatni bajt.

Funkcja nie zwraca wartości.

Całkiem przyzwoicie jak na język, który tak naprawdę nie robi nici.

Pełny program, 21 bajtów

Jeśli chcesz przekształcić go w pełny program, potrzeba tylko 5 dodatkowych bajtów. Zamiast przekazywać dane wejściowe do rejestru, odczytuje dane wejściowe z argumentów przekazanych w wierszu poleceń podczas wywoływania aplikacji. Argument 0 jest interpretowany jako falsey, podobnie jak całkowity brak argumentów; argument większy niż 0 jest interpretowany jako prawdziwy.

Po prostu złóż poniższy kod jako program COM, a następnie uruchom go w wierszu poleceń.

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

Przykładowe dane wyjściowe:

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

Jak to działa? Cóż, to w zasadzie to samo, dopóki nie przejdziesz do CMPinstrukcji. Porównuje to argument wiersza poleceń z wartością parametruDL rejestru (który, jak pamiętacie, zawiera ASCII „0”). W programie COM bajty kodu są ładowane z przesunięciem 0x100. Poprzednikiem jest prefiks segmentu programu (PSP) , który zawiera informacje o stanie programu DOS. W szczególności przy przesunięciu 0x82 znajduje się pierwszy (właściwie drugi, ponieważ pierwszy jest spacją) argument, który został podany w wierszu poleceń podczas wywoływania programu. Właśnie porównujemy ten bajt z ASCII „0”.

Porównanie ustawia flagi, a następnie SALCinstrukcja (nieudokumentowany kod operacyjny przed Pentium, równoważny sbb al, al, ale tylko 1 bajt zamiast 2) ustawia ALna 0, jeśli dwie wartości były równe, lub -1, jeśli były różne. Jest wtedy oczywiste, że kiedy odejmujemyAL od DLpowoduje to zarówno ASCII „0” lub „1”, odpowiednio.

(Zauważ, że nieco ironicznie złamiesz go, jeśli podasz argument z wiodącym 0 w wierszu poleceń, ponieważ wygląda tylko na pierwszy znak. 01Będzie to traktowane jak falsey. :-)

Python 3 , 23 bajty

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

Wypróbuj online!

JavaScript, 23 bajty

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

!!a wymusza a na boolean, który unary plus zmienia się w int.

V , 8 bajtów

32é0Àñl

Wypróbuj online!

Wyjaśnienie:

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 bajtów

ᛝΨβ_I

Wypróbuj online!

Wyjaśnienie:

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

Zapisano bajt dzięki Okx

Oktawa , 17 bajtów

@(n)dec2bin(n,32)

Funkcja anonimowa. Działa również w MATLAB.

Wypróbuj online!

ArnoldC , 369 bajtów

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

Wypróbuj online!

Brainfuck , 61 60 36 bajtów

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

Jestem pewien, że istnieje sprytny sposób, aby nie poruszać się tak bardzo za pomocą wskaźników.

Miałem rację. Byli. Dzięki @Graviton za pomysł!

Następny krok: Uzyskaj wartości 32 i 48 szybciej!

Wypróbuj 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.

To była zabawa dla pierwszego golfa!

Było już za późno. Co ja w ogóle robię

Scala, 32 bajty

Przepraszam, ale byłem zmuszony to zrobić w 32 bajtach> _ <

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

Jest on zawarty w funkcji przyjmującej tjako parametr (jako, stringże może to być „0” lub „1” dla odpowiednio fałszu lub prawdy) orazs jest zwracany.

Wypróbuj online!

Prawidłowa odpowiedź: Scala, 46 bajtów

Tak jak moja odpowiedź w języku Java, miałem wziąć wartość logiczną dla parametru. Więc :

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

Wypróbuj online!

Braingolf , 10 8 bajtów

#␟>[0_]N

Wypróbuj online!

␟ jest separatorem jednostek, ASCII 0x1F lub 31. Nie można znaleźć rzeczywistego znaku do wklejenia do TIO, więc TIO zamiast tego używa # 1-, co przesuwa spację (32) i zmniejsza do 31.

Wyjaśnienie

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

Oktawa , 23 bajty

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

Wypróbuj online!

Jest to krótsze niż wszystkie podejścia, z którymi próbowałem printf. Mogłem coś przeoczyć, ponieważ zrobiłem to na telefonie.

Tylko jeden bajt dłużej

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

Może to być 18 bajtów, gdybym mógł wziąć 1/0 jako łańcuch.

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

Wypróbuj online!

Java 8, 31 27 bajtów

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

-4 bajty dzięki @ OlivierGrégoire .

Wypróbuj tutaj.

05AB1E , 5 bajtów

¾31׫

Wypróbuj online!

Ruby, 21 bajtów

Tak, ta przestrzeń musi tam być ..: /

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

W Ruby wszystko oprócz falsei niljest prawdą; Wypróbuj online!

Mathematica, 36 bajtów

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

Mathematica, 26 bajtów

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

Wypróbuj online!

Węgiel drzewny , 5 bajtów

×0³¹Ｓ

Wypróbuj online! (Link do pełnej wersji).

Jak rozumie węgiel drzewny 0i 1jako Truelub False, to po prostu drukuje 31 0s, a dane wejściowe ( 0lub 1) jako ciąg.

Python 2 , 26 25 bajtów

Dzięki Erikowi Outgolferowi za uratowanie bajtu!

Idzie do pełnego podejścia programowego:

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

Wypróbuj online!

Niepożądane, niepotrzebne, oportunistyczne , 7 bajtów

P0M31P*

Podaj 1 lub 0 do rejestru.

C, 26 bajtów

Prawie taki sam pomysł jak rozwiązanie 1bluestone , ale w C jest krótszy i działa poprawnie dla każdego wejścia liczb całkowitych:

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

Oczywiście, to zawiera kilka niejawnie wpisywanych zmiennych / funkcji, jak wszystkie dobre odpowiedzi C-golf zrobić ... The !!operator jest najkrótsza droga do konwersji wszelkich wartość truthy się 1w C (przez podwójne zaprzeczenie, !definiuje się wrócić albo 1albo 0).

Testuj z:

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

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

Wypróbuj online!

Dzięki @nimi za -5bajty!

PHP, 28 bajtów

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

Zapisz jako bool.php i uruchom:

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

Ly , 20 15 13 bajtów

65*1+[0u1-]nu

EDYCJA: Oszczędność 5 bajtów dzięki ovs.
EDYCJA: Zapisano kolejne 2 bajty, drukując 0 jako liczbę, a nie znak.

Oktawa, 16 11 bajtów

@(x)x(1:32)

Wypróbuj online!

Uchwyt funkcyjny, który przyjmuje "00000000000000000000000000000001"zarówno prawdę, "00000000000000000000000000000000\0"jak i falsey.

Wyjaśnienie:

In Octave an array is considered as falsey if at least one of its elements is zero. The 33th element of the second string is a character with the ASCII value of 0 so it can be considered as falsey.

Java, 40 chars, 40 bytes

This takes string as parameter, which is not correct (falsy/truthy java value is forced by OP to be represented by a boolean).

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

Try It Online!

Valid response : Java, 60 chars, 60 bytes

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

Try It Online!

I know there is already a Java answer which is shorter than this one, but still :)

Japt, 13 11 bytes

?1:0 ¤i31ç0

Explanation:

?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

Saved a byte using a base-2 conversion built-in!

To insert the string of 0s in front of the 1/0, I need to cast the 1 and 0 into a string. The typical way of doing that would be 1s  (3 bytes). But because we're only converting 1s and 0s, I can use the base-2 built-in 1¤ (2 bytes).

Input can be in the form of an integer or string.

0 and "" are falsy in Japt.

Try it online!

Test suite

C# (.NET Core), 29 bytes

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

OP said 1/0 can be used for truthy/falsey, so can make a an int and it becomes

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

C# doesn't really have truthy/falsey though so I will not use this answer.

Try it online!

MY, 10 9 bytes

𝕫BṄiℑpέ←←

Try it online!

Explanation (codepage [with reasoning behind the character]/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)

I can't believe that this is possible without any two-argument commands whatsoever!

Edit: Saved 1 byte by using primes instead of arithmetic to get 31.

APL, 11 bytes

⍕¯32↑1↑1\⍨⊢

How?

1\⍨⊢ - repeat 1 input times - return empty array on falsy value

1↑ - take the first item

¯32↑ - align right with 31 zeros

⍕ - format as string

J, 11 bytes

(31#'0'),":

Try it online!

how?

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

note: in J, booleans are 0 or 1, also known as "the iverson convention," after ken iverson, creator of J and APL