Giới thiệu

Theo kinh điển, booleans là một bit; truehoặc false, 1hoặc 0. Số không hàng đầu sẽ chỉ là dư thừa. Ví dụ, 001có nghĩa giống như 00001hoặc chỉ 1.

Boolean 32 bit

Đưa ra một giá trị trung thực / falsey, xuất ra boolean 32 bit tương đương dưới dạng chuỗi. (Hoặc dưới dạng số nếu vì lý do nào đó, ngôn ngữ của bạn hỗ trợ các số 0 đứng đầu.)

Chương trình của bạn không phải làm việc cho mọi loại trung thực / giả, chỉ những gì ngôn ngữ lập trình của bạn hoạt động tốt nhất.

Ví dụ i / o

Input >> Output

truthy >> 00000000000000000000000000000001
falsey >> 00000000000000000000000000000000

Đây là mã golf , vì vậy byte thấp nhất sẽ thắng!

Python 3 , 33 25 18 15 byte

Cảm ơn @ Jurjen-bos cho tiền __mod__boa.

'%.32d'.__mod__

Hãy thử trực tuyến!

Mã máy x86-16 (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

Hàm trên nhận được giá trị boolean (0 == falsey, 1 == truey) trong thanh BLghi (byte thấp BX) và in chuỗi "boolean dự phòng" sang đầu ra tiêu chuẩn.

Nó hoạt động bằng cách gọi một ngắt (0x21) để thực hiện cuộc gọi chức năng DOS (được chọn bằng cách đặt AHthành 2) để in một ký tự (in DL) sang đầu ra tiêu chuẩn.

Đầu tiên, ký tự ASCII '0' được tải vào DL, bộ đếm ( CX) được đặt thành 31 và nó lặp để in các byte "dự phòng". Sau đó, giá trị boolean đầu vào được thêm vào DL(nếu BLlà falsey, thêm 0 sẽ DLkhông thay đổi dưới dạng ASCII '0'; nếu BLlà trung thực, DLsẽ được tăng thêm một đến ASCII '1') và byte cuối cùng được in.

Hàm không trả về giá trị.

Khá tốt cho một ngôn ngữ không thực sự làm chuỗi.

Chương trình đầy đủ, 21 byte

Nếu bạn muốn biến nó thành một chương trình đầy đủ, chỉ cần thêm 5 byte. Thay vì chuyển đầu vào trong một thanh ghi, điều này đọc đầu vào từ các đối số được truyền trên dòng lệnh khi gọi ứng dụng. Một đối số bằng 0 được hiểu là falsey, cũng như thiếu hoàn toàn các đối số; một đối số lớn hơn 0 được hiểu là sự thật.

Đơn giản chỉ cần lắp ráp mã sau đây như một chương trình COM, và sau đó thực thi nó trên dòng lệnh.

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

Đầu ra mẫu:

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

Làm thế nào nó hoạt động? Vâng, về cơ bản là điều tương tự, cho đến khi bạn nhận được CMPhướng dẫn. Điều này so sánh đối số dòng lệnh với giá trị của thanh DLghi (mà bạn nhớ lại có chứa ASCII '0'). Trong chương trình COM, các byte mã được tải ở offset 0x100. Trước đó là tiền tố phân đoạn chương trình (PSP) , chứa thông tin về trạng thái của chương trình DOS. Cụ thể, ở offset 0x82, bạn tìm thấy đối số thứ nhất (thực ra là thứ hai, vì thứ nhất là khoảng trắng) được chỉ định trên dòng lệnh khi chương trình được gọi. Vì vậy, chúng tôi chỉ so sánh byte này với ASCII '0'.

So sánh đặt các cờ và sau đó là SALClệnh (một mã opcode không có giấy tờ trước Pentium, tương đương sbb al, al, nhưng chỉ 1 byte thay vì 2) đặt ALthành 0 nếu hai giá trị bằng nhau hoặc -1 nếu chúng khác nhau. Đó là sau đó rõ ràng rằng khi chúng ta trừ ALtừ DL, kết quả này trong hoặc ASCII '0' hoặc '1', khi thích hợp.

(Lưu ý rằng, hơi mỉa mai, bạn sẽ phá vỡ nó nếu bạn vượt qua một đối số có số 0 đứng đầu trên dòng lệnh, vì nó chỉ nhìn vào ký tự đầu tiên. Vì vậy, 01sẽ được coi là falsey. :-)

Python 3 , 23 byte

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

Hãy thử trực tuyến!

Javascript, 23 byte

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

!!a ép buộc a thành một boolean, mà phép cộng unary biến thành int.

V , 8 byte

32é0Àñl

Hãy thử trực tuyến!

Giải trình:

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

Hãy thử trực tuyến!

Giải trình:

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

Đã lưu một byte nhờ Okx

Octave , 17 byte

@(n)dec2bin(n,32)

Chức năng ẩn danh. Hoạt động trong MATLAB cũng vậy.

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Brainfuck , 61 60 36 byte

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

Tôi chắc chắn có một cách thông minh là không di chuyển xung quanh quá nhiều với các con trỏ.

Tôi đã đúng. Có. Cảm ơn @Graviton đã cho tôi ý tưởng!

Bước tiếp theo: Nhận các giá trị 32 và 48 nhanh hơn!

Hãy thử trực tuyến!

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

Thật thú vị cho một Golf đầu tiên!

Nó đã nhận được quá muộn bây giờ. Tôi thậm chí đang làm gì

Scala, 32 byte

Xin lỗi nhưng tôi đã buộc phải làm điều đó trong 32 byte> _ <

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

Nó được bao bọc bởi một hàm lấy ttham số (như một tham số stringcó thể là "0" hoặc "1" cho sự tôn trọng hoặc sai sự thật) và sđược trả về.

Dùng thử trực tuyến!

Phản hồi hợp lệ: Scala, 46 byte

Giống như phản hồi java của tôi, tôi phải có một giá trị boolean cho tham số. Vì thế :

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

Dùng thử trực tuyến!

Braingolf , 10 8 byte

#␟>[0_]N

Hãy thử trực tuyến!

␟là Dấu phân cách đơn vị, ASCII 0x1Fhoặc 31. Không thể tìm thấy ký tự thực sự để dán vào TIO, vì vậy TIO thay vào đó sử dụng # 1-, đẩy không gian (32) và giảm xuống 31.

Giải trình

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

Octave , 23 byte

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

Hãy thử trực tuyến!

Điều này ngắn hơn tất cả các phương pháp tôi đã thử với printf. Tôi có thể đã bỏ lỡ một cái gì đó, vì tôi đã làm điều này trên điện thoại của tôi.

Chỉ còn một byte nữa

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

Đây có thể là 18 byte nếu tôi có thể lấy 1/0 làm chuỗi.

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

Hãy thử trực tuyến!

Java 8, 31 27 byte

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

-4 byte nhờ @ OlivierGrégoire .

Hãy thử nó ở đây.

05AB1E , 5 byte

¾31׫

Hãy thử trực tuyến!

Ruby, 21 byte

Vâng, không gian đó cần phải ở đó ..: /

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

Trong Ruby mọi thứ ngoại trừ falsevà nillà sự thật; Hãy thử trực tuyến!

Toán học, 36 byte

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

Toán học, 26 byte

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

Hãy thử trực tuyến!

Than , 5 byte

×0³¹Ｓ

Hãy thử trực tuyến! (Liên kết đến phiên bản dài dòng.)

Như Char than hiểu 0và 1như Truehoặc False, điều này chỉ in 31 0giây và đầu vào ( 0hoặc 1) dưới dạng chuỗi.

Python 2 , 26 25 byte

Cảm ơn Erik, Outgolfer đã lưu một byte!

Đi cho cách tiếp cận chương trình đầy đủ:

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

Hãy thử trực tuyến!

Không mong muốn, không cần thiết, cơ hội , 7 byte

P0M31P*

Vượt qua 1 hoặc 0 vào thanh ghi.

C, 26 byte

Khá nhiều ý tưởng giống như giải pháp của 1bluestone , nhưng trong C thì nó ngắn hơn và nó hoạt động chính xác cho bất kỳ đầu vào số nguyên nào:

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

Tất nhiên, điều này bao gồm một số biến / hàm được gõ ngầm vì tất cả các câu trả lời C-golf tốt đều làm ... !!Toán tử là cách ngắn nhất để chuyển đổi bất kỳ giá trị trung thực nào sang 1C (thông qua phủ định kép, !được xác định để trả về1 hoặc0 ).

Kiểm tra với:

#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

Hãy thử trực tuyến!

Cảm ơn @nimi cho -5byte!

PHP, 28 byte

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

Lưu dưới dạng bool.php và chạy:

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

Ly , 20 15 13 byte

65*1+[0u1-]nu

EDIT: Đã lưu 5 byte nhờ vào ovs.
EDIT: Đã lưu 2 byte khác bằng cách in 0 dưới dạng số thay vì ký tự.

Octave, 16 11 byte

@(x)x(1:32)

Hãy thử trực tuyến!

Một hàm xử lý có "00000000000000000000000000000001"tính trung thực và "00000000000000000000000000000000\0"như falsey.

Giải trình:

Trong Octave, một mảng được coi là falsey nếu ít nhất một trong các phần tử của nó bằng không. Phần tử thứ 33 của chuỗi thứ hai là một ký tự có giá trị ASCII bằng 0 nên có thể được coi là falsey.

Java, 40 ký tự, 40 byte

Điều này lấy chuỗi làm tham số, không chính xác (giá trị java falsy / truey bị OP buộc phải được đại diện bởi một boolean).

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

Dùng thử trực tuyến!

Phản hồi hợp lệ: Java, 60 ký tự, 60 byte

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

Dùng thử trực tuyến!

Tôi biết đã có một câu trả lời Java ngắn hơn câu trả lời này, nhưng vẫn :)

Japt , 13 11 byte

?1:0 ¤i31ç0

Giải trình:

?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

Đã lưu một byte bằng cách sử dụng chuyển đổi cơ sở 2!

Để chèn chuỗi 0 vào trước 1/ 0, tôi cần truyền 1và 0vào chuỗi. Cách điển hình để làm điều đó sẽ là 1s (3 byte). Nhưng vì chúng tôi chỉ chuyển đổi 1 và 0, nên tôi có thể sử dụng cơ sở 2 tích hợp 1¤(2 byte).

Đầu vào có thể ở dạng số nguyên hoặc chuỗi.

0 và "" là giả trong Japt.

Hãy thử trực tuyến!

Bộ kiểm tra

C # (.NET Core) , 29 byte

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

OP cho biết 1/0 có thể được sử dụng cho sự thật / falsey, vì vậy có thể tạo amột int và nó trở thành

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

C # không thực sự có sự thật / falsey mặc dù vậy tôi sẽ không sử dụng câu trả lời này.

Hãy thử trực tuyến!

TÔI , 10 9 byte

𝕫BṄiℑpέ←←

Hãy thử trực tuyến!

Giải thích (codepage [với lý do đằng sau ký tự] / mã hex):

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

Tôi không thể tin rằng điều này là có thể nếu không có bất kỳ lệnh hai đối số nào!

Chỉnh sửa: Đã lưu 1 byte bằng cách sử dụng các số nguyên tố thay vì số học để có được 31.

APL, 11 byte

⍕¯32↑1↑1\⍨⊢

Làm sao?

1\⍨⊢ - lặp lại 1 lần đầu vào - trả về mảng trống trên giá trị giả

1↑ - lấy mục đầu tiên

¯32↑ - căn chỉnh đúng với 31 số không

⍕ - định dạng dưới dạng chuỗi

J, 11 byte

(31#'0'),":

Hãy thử trực tuyến!

làm sao?

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

lưu ý: trong J, booleans là 0 hoặc 1, còn được gọi là "quy ước iverson", sau ken iverson, người tạo ra J và APL