pengantar

Secara klasik, boolean sedikit berbeda; trueatau false, 1atau 0. Angka nol terdepan hanya akan menjadi berlebihan. Misalnya, 001artinya sama dengan 00001atau adil 1.

Boolean 32-bit

Diberikan nilai truey / falsey, output setara boolean 32-bit sebagai string. (Atau sebagai nomor jika karena alasan tertentu bahasa Anda mendukung angka nol di muka.)

Program Anda tidak harus bekerja untuk setiap jenis kebenaran / kepalsuan, hanya apa yang paling cocok untuk bahasa pemrograman Anda.

Contoh i / o

Input >> Output

truthy >> 00000000000000000000000000000001
falsey >> 00000000000000000000000000000000

Ini adalah kode-golf , sehingga byte terendah menang!

Python 3 , 33 25 18 15 byte

Terima kasih @ jurjen-bos untuk __mod__tipnya.

'%.32d'.__mod__

Cobalah online!

x86-16 Kode Mesin (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

Fungsi di atas menerima nilai boolean (0 == falsey, 1 == truthy) dalam BLregister (byte rendah BX), dan mencetak string "redundant boolean" ke output standar.

Ia bekerja dengan menggunakan interupsi (0x21) untuk membuat panggilan fungsi DOS (dipilih dengan menetapkan AHke 2) yang mencetak satu karakter (dalam DL) ke output standar.

Pertama, karakter ASCII '0' dimasukkan ke dalam DL, penghitung ( CX) diatur ke 31, dan loop untuk mencetak byte "redundan". Kemudian, nilai input boolean ditambahkan ke DL(jika BLfalsey, menambahkan 0 tidak akan DLberubah sebagai ASCII '0'; jika BLbenar, DLakan ditambahkan oleh satu ke ASCII '1'), dan byte terakhir dicetak.

Fungsi tidak mengembalikan nilai.

Lumayan untuk bahasa yang tidak terlalu bagus.

Program Lengkap, 21 byte

Jika Anda ingin membuatnya menjadi program penuh, hanya 5 byte lagi diperlukan. Alih-alih memasukkan input dalam register, ini membaca input dari argumen yang dilewatkan pada baris perintah ketika memanggil aplikasi. Argumen 0 diartikan sebagai falsey, seperti halnya kurangnya argumen; argumen yang lebih besar dari 0 ditafsirkan sebagai kebenaran.

Cukup kumpulkan kode berikut sebagai program COM, dan kemudian jalankan di baris perintah.

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

Output sampel:

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

Bagaimana cara kerjanya? Yah, pada dasarnya hal yang sama, sampai Anda selesai dengan CMPinstruksi. Ini membandingkan argumen baris perintah dengan nilai DLregister (yang, Anda ingat, berisi ASCII '0'). Dalam program COM, byte kode dimuat pada offset 0x100. Sebelumnya itu adalah awalan segmen program (PSP) , yang berisi informasi tentang keadaan program DOS. Khususnya, pada offset 0x82, Anda menemukan argumen pertama (sebenarnya yang kedua, karena argumen pertama adalah spasi) yang ditentukan pada baris perintah ketika program dipanggil. Jadi, kami hanya membandingkan byte ini dengan ASCII '0'.

Perbandingan menetapkan bendera, dan kemudian SALCinstruksi (opcode tidak berdokumen sebelum Pentium, setara dengan sbb al, al, tetapi hanya 1 byte, bukan 2) ditetapkan ALke 0 jika kedua nilai sama, atau -1 jika keduanya berbeda. Hal ini kemudian jelas bahwa ketika kita kurangi ALdari DL, hasil ini baik ASCII '0' atau '1', yang sesuai.

(Perhatikan bahwa, agak ironisnya, Anda akan memecahnya jika Anda melewati argumen dengan 0 di baris perintah, karena itu hanya terlihat pada karakter pertama. Jadi 01akan diperlakukan sebagai falsey. :-)

Python 3 , 23 byte

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

Cobalah online!

Javascript, 23 byte

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

!!a memaksa a menjadi boolean, yang plus plus unary berubah menjadi int.

V , 8 byte

32é0Àñl

Cobalah online!

Penjelasan:

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

Cobalah online!

Penjelasan:

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

Menyimpan satu byte berkat Okx

Oktaf , 17 byte

@(n)dec2bin(n,32)

Fungsi anonim. Bekerja di MATLAB juga.

Cobalah online!

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

Cobalah online!

Brainfuck , 61 60 36 byte

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

Saya yakin ada cara yang cerdas untuk tidak terlalu banyak bergerak dengan pointer.

Saya benar. Ada. Terima kasih kepada @Graviton karena telah memberikan saya ide!

Langkah selanjutnya: Dapatkan nilai 32 dan 48 lebih cepat!

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

Menyenangkan untuk Golf pertama!

Sudah terlambat sekarang. Apa yang saya lakukan

Scala, 32 byte

Maaf tapi saya terpaksa melakukannya dalam 32 byte> _ <

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

Itu tertutup oleh fungsi yang mengambil tparameter (sebagai stringyang bisa "0" atau "1" untuk resp. Falsy atau truthy), dan sdikembalikan.

Cobalah secara Online!

Respons yang valid: Scala, 46 byte

Sama seperti respons java saya, saya seharusnya mengambil boolean untuk parameter. Jadi:

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

Cobalah secara Online!

Braingolf , 10 8 byte

#␟>[0_]N

Cobalah online!

␟adalah Unit Separator, ASCII 0x1F, atau 31. Tidak dapat menemukan karakter yang sebenarnya untuk ditempelkan ke TIO, jadi TIO malah menggunakan# 1- , yang mendorong spasi (32) dan menurun menjadi 31.

Penjelasan

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

Oktaf , 23 byte

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

Cobalah online!

Ini lebih pendek dari semua pendekatan yang saya coba printf. Saya mungkin telah melewatkan sesuatu, karena saya melakukan ini di ponsel saya.

Hanya satu byte lebih panjang

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

Ini bisa 18 byte jika saya bisa mengambil 1/0 sebagai string.

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

Cobalah online!

Java 8, 31 27 byte

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

-4 byte terima kasih kepada @ OlivierGrégoire .

Coba di sini.

05AB1E , 5 byte

¾31׫

Cobalah online!

Ruby, 21 byte

Ya, ruang itu harus ada di sana ..: /

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

Di Ruby semuanya kecuali falsedan nilbenar; Cobalah online!

Mathematica, 36 byte

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

Mathematica, 26 byte

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

Cobalah online!

Arang , 5 byte

×0³¹Ｓ

Cobalah online! (Tautan ke versi verbose.)

Sebagai Charcoal mengerti 0dan 1sebagai Trueatau False, ini hanya mencetak 31 0detik dan input ( 0atau 1) sebagai string.

Python 2 , 26 25 byte

Berkat Erik, Outgolfer karena telah menghemat satu byte!

Goes for the full program approach:

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

Cobalah online!

Tidak Diinginkan, Tidak Perlu, Oportunistik , 7 byte

P0M31P*

Masukkan 1 atau 0 ke dalam register.

C, 26 byte

Gagasan yang hampir sama dengan solusi 1bluestone , tetapi dalam C lebih pendek, dan berfungsi dengan benar untuk setiap input integer:

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

Tentu saja, ini termasuk beberapa variabel / fungsi yang diketik secara implisit karena semua jawaban C-golf yang bagus lakukan ... !!Operator adalah cara terpendek untuk mengonversi nilai kebenaran apa pun ke 1dalam C (melalui negasi ganda, !didefinisikan untuk mengembalikan salah satu 1atau 0).

Uji dengan:

#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

Cobalah online!

Terima kasih @nimi untuk -5byte!

PHP, 28 byte

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

Simpan sebagai bool.php dan jalankan:

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

Ly , 20 15 13 byte

65*1+[0u1-]nu

EDIT: Disimpan 5 byte berkat ovs.
EDIT: Menyimpan 2 byte lainnya dengan mencetak 0 sebagai angka daripada karakter.

Oktaf, 16 11 byte

@(x)x(1:32)

Cobalah online!

Sebuah fungsi menangani yang "00000000000000000000000000000001"dianggap sebagai kebenaran dan "00000000000000000000000000000000\0" kepalsuan.

Penjelasan:

Dalam Oktaf, sebuah array dianggap sebagai falsey jika setidaknya salah satu elemennya nol. Elemen ke-33 dari string kedua adalah karakter dengan nilai ASCII dari 0 sehingga dapat dianggap sebagai falsey.

Java, 40 karakter, 40 byte

Ini mengambil string sebagai parameter, yang tidak benar (nilai java falsy / truthy dipaksa oleh OP untuk diwakili oleh boolean).

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

Cobalah secara Online!

Respons yang valid: Java, 60 karakter, 60 byte

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

Cobalah secara Online!

Saya tahu sudah ada jawaban Java yang lebih pendek dari yang ini, tapi tetap saja :)

Japt , 13 11 byte

?1:0 ¤i31ç0

Penjelasan:

?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

Menyimpan byte menggunakan konversi basis-2 bawaan!

Untuk memasukkan string 0s di depan 1/ 0, saya harus memasukkan 1dan 0ke dalam string. Cara khas untuk melakukan itu adalah 1s (3 byte). Tetapi karena kita hanya mengonversi 1s dan 0s, saya dapat menggunakan basis-2 built-in 1¤(2 byte).

Input bisa dalam bentuk integer atau string.

0dan ""palsu dalam Japt.

Cobalah online!

Suite uji

C # (.NET Core) , 29 byte

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

OP mengatakan 1/0 dapat digunakan untuk truthy / falsey, sehingga dapat membuat aint dan menjadi

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

C # tidak benar-benar memiliki kebenaran / kesalahan jadi saya tidak akan menggunakan jawaban ini.

Cobalah online!

SAYA , 10 9 byte

𝕫BṄiℑpέ←←

Cobalah online!

Penjelasan (codepage [dengan alasan di belakang karakter] / kode 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)

Saya tidak percaya ini mungkin tanpa ada dua argumen yang memerintahkan!

Sunting: Disimpan 1 byte dengan menggunakan bilangan prima alih-alih aritmatika untuk mendapatkan 31.

APL, 11 byte

⍕¯32↑1↑1\⍨⊢

Bagaimana?

1\⍨⊢ - ulangi 1 kali input - kembalikan array kosong pada nilai falsy

1↑ - ambil item pertama

¯32↑ - sejajarkan ke kanan dengan 31 angka nol

⍕ - memformat sebagai string

J, 11 byte

(31#'0'),":

Cobalah online!

bagaimana?

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

catatan: dalam J, boolean adalah 0 atau 1, juga dikenal sebagai "konvensi iverson," setelah ken iverson, pencipta J dan APL