Вступ

Класично булеви - це один біт; trueабо false, 1або 0. Провідні нулі були б просто зайвими. Наприклад, 001означає те саме, що 00001або просто 1.

32-бітний булів

Враховуючи коефіцієнт truthy / falsey, виведіть еквівалентний 32-бітовий булевий як рядок. (Або як число, якщо з якихось причин ваша мова підтримує провідні нулі.)

Вашій програмі не потрібно працювати для кожного типу "фальшивого / хибного", тільки найкраще працює ваша мова програмування.

Приклад i / o

Input >> Output

truthy >> 00000000000000000000000000000001
falsey >> 00000000000000000000000000000000

Це код-гольф , тому виграє найнижчий байт!

Python 3 , 33 25 18 15 байт

Дякую @ jurjen-bos за __mod__пораду.

'%.32d'.__mod__

Спробуйте в Інтернеті!

x86-16 Машинний код (DOS), 16 байт

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

Вищенаведена функція отримує булеве значення (0 == фальси, 1 == truthy) у BL (низький байт BX) і друкує "зайвий булевий" рядок до стандартного виводу.

Він працює, викликаючи переривання (0x21), щоб здійснити виклик функції DOS (вибрано налаштуванням) AH на 2), який друкує один символ (в DL) на стандартний вихід.

По-перше, символ "0" ASCII завантажується в DLлічильник, лічильник ( CX) встановлюється на 31, і він петлює для друку "зайвих" байтів. Потім додається булева величина вводу DL(якщо BLє фальси, додавання 0 залишатиметься DLнезмінним як ASCII '0'; якщо BLє truthy, DLбуде збільшуватися на 1 до ASCII '1'), і друкується остаточний байт.

Функція не повертає значення.

Досить пристойний для мови, яка насправді не створює рядки.

Повна програма, 21 байт

Якщо ви хочете перетворити його на повну програму, потрібно лише ще 5 байт. Замість передачі введення в регістр, це зчитує вхід з аргументів, переданих у командному рядку при виклику програми. Аргумент 0 трактується як фальси, як і повна відсутність аргументів; аргумент, більший за 0, трактується як правдивий.

Просто зберіть наступний код як програму COM і виконайте його в командному рядку.

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

Вибірка зразка:

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

Як це працює? Ну, це в основному те саме, поки ви не приступите до CMPінструкції. Це порівнює аргумент командного рядка зі значенням DLрегістру (який, нагадаєте, містить ASCII '0'). У програмі COM байти коду завантажуються зі зміщенням 0x100. Попередній префікс програмного сегмента (PSP) , який містить інформацію про стан програми DOS. Зокрема, при зміщенні 0x82 ви знаходите перший (власне другий, оскільки перший - пробіл) аргумент, який був вказаний у командному рядку під час виклику програми. Отже, ми просто порівнюємо цей байт з ASCII '0'.

Порівняння встановлює прапори, а потім SALCінструкція (незадокументований код коду перед Pentium, еквівалентний sbb al, al, але лише 1 байт замість 2) встановлює AL0, якщо два значення були рівними, або -1, якщо вони були різними. Тоді очевидно, що коли ми віднімаємо ALвідDL , це призводить або ASCII «0» або «1», в залежності від обставин.

(Зауважте, що дещо іронічно, ви зламаєте його, якщо передасте аргумент із провідним 0 у командному рядку, оскільки він виглядає лише на першому символі. Тому 01буде трактуватися як фальси. :-)

Python 3 , 23 байти

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

Спробуйте в Інтернеті!

Javascript, 23 байти

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

!!a примушує a в булевий, який одинарний плюс перетворюється на int.

V , 8 байт

32é0Àñl

Спробуйте в Інтернеті!

Пояснення:

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

Нейм , 6 5 байт

ᛝΨβ_I

Спробуйте в Інтернеті!

Пояснення:

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

Збережено байт завдяки Okx

Октава , 17 байт

@(n)dec2bin(n,32)

Анонімна функція. Працює і в MATLAB.

Спробуйте в Інтернеті!

ArnoldC , 369 байт

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

Спробуйте в Інтернеті!

Brainfuck , 61 60 36 байт

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

Я впевнений, що є розумний спосіб не рухатись так багато вказівниками.

Я був правий. Там були. Дякую @Graviton за те, що дав мені ідею!

Наступний крок: швидше отримуйте значення 32 та 48!

Спробуйте в Інтернеті!

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

Було весело для першого Гольфу!

Зараз це стало занадто пізно. Що я навіть роблю

Scala, 32 байти

Вибачте, але мене змусили це зробити в 32 байтах> _ <

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

Він укладений функцією, яка приймає tза параметр (як a, stringякий може бути "0" або "1" для відповідних ложних або правдоподібних), іs повертається.

Спробуйте в Інтернеті!

Дійсна відповідь: Scala, 46 байт

Як і моя відповідь java, я повинен був взяти булевий параметр. Так :

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

Спробуйте в Інтернеті!

Braingolf , 10 8 байт

#␟>[0_]N

Спробуйте в Інтернеті!

␟є роздільником одиниць, ASCII 0x1Fабо 31. Неможливо знайти фактично символу, який потрібно вставити в TIO, тому TIO замість цього використовує # 1-, що висуває пробіл (32) та зменшення до 31.

Пояснення

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

Октава , 23 байти

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

Спробуйте в Інтернеті!

Це коротше, ніж усі підходи, з якими я намагався printf. Я, можливо, щось пропустив, оскільки робив це по телефону.

Лише на один байт довше

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

Це може бути 18 байт, якби я міг прийняти 1/0 як рядки.

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

Спробуйте в Інтернеті!

Java 8, 31 27 байт

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

-4 байти завдяки @ OlivierGrégoire .

Спробуйте тут.

05AB1E , 5 байт

¾31׫

Спробуйте в Інтернеті!

Рубін, 21 байт

Так, цей простір повинен бути там ..: /

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

У Рубі все, окрім falseі nilє правдою; Спробуйте в Інтернеті!

Mathematica, 36 bytes

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

Mathematica, 26 bytes

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

Try it online!

Charcoal, 5 bytes

×0³¹Ｓ

Try it online! (Link to the verbose version.)

As Charcoal understand 0 and 1 as True or False, this just prints 31 0s and the input (0 or 1) as string.

Python 2, 26 25 bytes

Thanks to Erik the Outgolfer for saving a byte!

Goes for the full program approach:

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

Try it online!

Unwanted, Unnecessary, Opportunistic, 7 bytes

P0M31P*

Pass either 1 or 0 into the register.

C, 26 bytes

Pretty much the same idea as 1bluestone's solution, but in C it's shorter, and it does work correctly for any integer input:

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

Of course, this includes some implicitly typed variables/functions as all good C-golf answers do... The !! operator is the shortest way to convert any truthy value to 1 in C (via double negation, ! is defined to return either 1 or 0).

Test with:

#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

Try it online!

Thanks @nimi for -5 bytes!

PHP, 28 bytes

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

Save as bool.php and run:

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

Ly, 20 15 13 bytes

65*1+[0u1-]nu

EDIT: Saved 5 bytes thanks to ovs.
EDIT: Saved another 2 bytes by printing 0 as a number rather than a character.

Octave,16 11 bytes

@(x)x(1:32)

Try it online!

A function handle that takes "00000000000000000000000000000001" as truthy and "00000000000000000000000000000000\0" as falsey.

Explanation:

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