บทนำ

คลาสสิก booleans เป็นหนึ่งบิต; trueหรือfalse, หรือ1 0ศูนย์ชั้นนำก็จะถูกซ้ำซ้อน ยกตัวอย่างเช่น001หมายความว่าเช่นเดียวกับหรือเพียงแค่000011

บูลีน 32 บิต

กำหนดค่าความจริง / เท็จให้เอาต์พุตบูลีน 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 == falsey, 1 == ความจริง) ในBLรีจิสเตอร์ (ไบต์ต่ำBX) และพิมพ์สตริง "บูลีนซ้ำซ้อน" ไปยังเอาต์พุตมาตรฐาน

มันทำงานได้โดยการเรียกใช้ขัดจังหวะ (0x21) เพื่อทำการเรียกฟังก์ชั่น DOS (เลือกโดยการตั้งค่าAHเป็น 2) ที่พิมพ์อักขระเดียว (ในDL) เพื่อออกมาตรฐาน

ขั้นแรกให้ใส่อักขระ ASCII '0' DLตัวนับ ( CX) ตั้งค่าเป็น 31 และวนซ้ำเพื่อพิมพ์ไบต์ "ซ้ำซ้อน" จากนั้นค่าบูลีนอินพุตจะถูกเพิ่มลงในDL(หากBLเป็นเท็จการเพิ่ม 0 จะDLไม่เปลี่ยนแปลงเป็น ASCII '0' หากBLเป็นความจริงDLจะถูกเพิ่มขึ้นทีละหนึ่งเป็น 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คำสั่ง (opcode ที่ไม่มีเอกสารก่อน Pentium เทียบเท่ากับsbb al, alแต่เพียง 1 ไบต์แทน 2) ตั้งค่าALเป็น 0 ถ้าทั้งสองค่าเท่ากันหรือ -1 ถ้าพวกเขาแตกต่างกัน แล้วมันเป็นที่ชัดเจนว่าเมื่อเราลบALจากDLผลนี้ทั้งใน ASCII '0' หรือ '1' ตามความเหมาะสม

(โปรดสังเกตว่าค่อนข้างเป็นเรื่องประชดประชันคุณจะทำลายมันถ้าคุณผ่านการโต้แย้งด้วย 0 นำหน้าในบรรทัดคำสั่งเนื่องจากมันดูเฉพาะอักขระตัวแรกเท่านั้นดังนั้น01จะถือว่าเป็น falsey :-)

Python 3 , 23 ไบต์

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

ลองออนไลน์!

Javascript, 23 ไบต์

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

!!a บีบบังคับ a เป็นบูลีนซึ่ง unary plus เปลี่ยนเป็น 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

Neim , 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.

สนุกกับการเล่นกอล์ฟครั้งแรก!

ตอนนี้มันสายเกินไปแล้ว ฉันกำลังทำอะไรอยู่

สกาลา, 32 ไบต์

ขออภัย แต่ฉันถูกบังคับให้ทำใน 32 ไบต์> _ <

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

มันถูกล้อมรอบด้วยฟังก์ชั่นการtเป็นพารามิเตอร์ (เป็นstringที่สามารถเป็น "0" หรือ "1" สำหรับ resp. เท็จหรือจริง) และ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 ไบต์

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

Mathematica ขนาด 26 ไบต์

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

ลองออนไลน์!

ถ่าน 5 ไบต์

×0³¹Ｓ

ลองออนไลน์! (ลิงก์ไปยังรุ่น verbose)

ตามที่ Charcoal เข้าใจ0และ1เป็นTrueหรือFalseเพียงแค่พิมพ์ 31 0s และอินพุต ( 0หรือ1) เป็นสตริง

Python 2 , 26 25 ไบต์

ขอบคุณErik the Outgolferสำหรับการบันทึกไบต์!

ไปสำหรับวิธีการแบบเต็มโปรแกรม:

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

ลองออนไลน์!

ไม่ต้องการ, ไม่จำเป็น, โอกาส , 7 ไบต์

P0M31P*

ส่ง 1 หรือ 0 ไปยังการลงทะเบียน

C, 26 ไบต์

แนวคิดเดียวกับโซลูชันของ 1bluestone ค่อนข้างมาก แต่ใน C สั้นกว่าและทำงานได้อย่างถูกต้องสำหรับอินพุตจำนวนเต็มใด ๆ :

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

ของหลักสูตรนี้รวมถึงบางส่วนพิมพ์โดยปริยายตัวแปร / ฟังก์ชั่นที่ดีทุกคำตอบ C-กอล์ฟทำ ... ความ!!ประกอบเป็นทางที่สั้นที่สุดในการแปลงค่า truthy ใด ๆ ที่1ใน C (ผ่านการปฏิเสธคู่!ถูกกำหนดให้กลับมาอย่างใดอย่างหนึ่ง1หรือ0)

ทดสอบกับ:

#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 ไบต์

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

ลองออนไลน์!

ขอบคุณ @nimi สำหรับ-5ไบต์!

PHP, 28 ไบต์

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

บันทึกเป็น bool.php และเรียกใช้:

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

Ly , 20 15 13 ไบต์

65*1+[0u1-]nu

แก้ไข: บันทึก 5 ไบต์ขอบคุณ ovs
แก้ไข: บันทึกอีก 2 ไบต์โดยพิมพ์ 0 เป็นตัวเลขแทนที่จะเป็นตัวอักษร

ระดับเสียงคู่, 16 11 ไบต์

@(x)x(1:32)

ลองออนไลน์!

การจัดการฟังก์ชั่นที่ใช้"00000000000000000000000000000001"เป็นความจริงและ "00000000000000000000000000000000\0"เป็นเท็จ

คำอธิบาย:

ในอ็อกเทฟอาเรย์จะถือเป็นเท็จถ้าองค์ประกอบอย่างน้อยหนึ่งองค์ประกอบเป็นศูนย์ องค์ประกอบที่ 33 ของสตริงที่สองเป็นตัวละครที่มีค่า ASCII เป็น 0 ดังนั้นจึงถือได้ว่าเป็นเท็จ

Java, 40 ตัวอักษร, 40 ไบต์

สิ่งนี้ใช้สตริงเป็นพารามิเตอร์ซึ่งไม่ถูกต้อง (ค่า java falsy / truey ถูกบังคับโดย OP เพื่อให้แสดงโดยบูลีน)

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

ลองออนไลน์!

การตอบสนองที่ถูกต้อง: Java, 60 chars, 60 bytes

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

ลองออนไลน์!

ฉันรู้ว่ามีคำตอบ Java อยู่แล้วซึ่งสั้นกว่าคำตอบนี้ แต่ก็ยัง :)

Japt , 13 11 ไบต์

?1:0 ¤i31ç0

คำอธิบาย:

?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

บันทึกไบต์โดยใช้การแปลงฐาน 2 ในตัว!

ในการแทรกสตริง 0s ที่ด้านหน้า1/ 0ฉันจำเป็นต้องส่ง1และ0ลงในสตริง วิธีการทั่วไปในการทำเช่นนั้นจะเป็น1s (3 ไบต์) แต่เนื่องจากเราแปลง 1s และ 0s เท่านั้นฉันจึงสามารถใช้ base-2 ในตัว1¤(2 ไบต์)

อินพุตสามารถอยู่ในรูปแบบของจำนวนเต็มหรือสตริง

0และ""เป็นเท็จใน Japt

ลองออนไลน์!

ชุดทดสอบ

C # (. NET Core) 29 ไบต์

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

OP กล่าวว่า 1/0 สามารถใช้เพื่อความจริง / เท็จได้ดังนั้นสามารถสร้างaint และมันจะกลายเป็น

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

C # ไม่ได้มีความจริง / เท็จจริง ๆ ดังนั้นฉันจะไม่ใช้คำตอบนี้

ลองออนไลน์!

MY , 10 9 ไบต์

𝕫BṄiℑpέ←←

ลองออนไลน์!

คำอธิบาย (เพจรหัส [ด้วยการให้เหตุผลที่อยู่เบื้องหลังอักขระ] / รหัสฐานสิบหก):

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

ฉันไม่อยากเชื่อเลยว่าสิ่งนี้จะเกิดขึ้นหากไม่มีคำสั่งสองข้อโต้แย้งใด ๆ !

แก้ไข: บันทึก 1 ไบต์โดยใช้ primes แทนเลขคณิตเพื่อให้ได้ 31

APL ขนาด 11 ไบต์

⍕¯32↑1↑1\⍨⊢

อย่างไร?

1\⍨⊢ - ทำซ้ำ 1 ครั้งอินพุต - ส่งคืนอาเรย์ที่ว่างเปล่าตามค่าที่ผิดพลาด

1↑ - รับไอเท็มแรก

¯32↑ - จัดชิดขวาด้วย 31 ศูนย์

⍕ - จัดรูปแบบเป็นสตริง

J, 11 ไบต์

(31#'0'),":

ลองออนไลน์!

อย่างไร

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

หมายเหตุ: ใน J, บูลีนคือ 0 หรือ 1 หรือที่เรียกว่า "การประชุม iverson" หลังจาก ken iverson ผู้สร้าง J และ APL