บูลีนที่ซ้ำซ้อน


19

บทนำ

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

บูลีน 32 บิต

กำหนดค่าความจริง / เท็จให้เอาต์พุตบูลีน 32- บิตเทียบเท่าเป็นสตริง (หรือเป็นตัวเลขถ้าด้วยเหตุผลบางอย่างภาษาของคุณสนับสนุนศูนย์นำหน้า)

โปรแกรมของคุณไม่จำเป็นต้องทำงานกับความจริง / เท็จทุกประเภทเฉพาะภาษาโปรแกรมของคุณที่ดีที่สุด

ตัวอย่าง i / o

Input >> Output

truthy >> 00000000000000000000000000000001
falsey >> 00000000000000000000000000000000

นี่คือดังนั้นไบต์ที่ต่ำที่สุดจึงชนะ!


6
เราจำเป็นต้องจัดการกับความจริงหรือความเท็จที่เป็นไปได้หรือเพียงแค่บูลีนหรือไม่
xnor

หากภาษาของฉันรองรับประเภทและมีบูลีนฉันสามารถใช้ 1 (int) เป็นความจริงได้หรือไม่
LiefdeWen

@LiefdeWen แน่นอน
Graviton

1
ไม่ซ้ำกันอีกต่อไปเนื่องจากอินพุตที่แท้จริง / เป็นเท็จอาจไม่แตกต่างกันสำหรับแต่ละคำตอบ / ภาษา
Graviton

ฉันไม่เห็นว่าทำไมนอกจากฮะโอเค ~
V. Courtois

คำตอบ:


10

Python 3 , 33 25 18 15 ไบต์

ขอบคุณ @ jurjen-bos สำหรับคำ__mod__แนะนำ

'%.32d'.__mod__

ลองออนไลน์!


จะlambda b:'%0.32d'%bทำงานอย่างไร
2560

โอ้None จริงหรือเท็จ ?
2560

@BruceForte Falsey
wrymug

1
เช่นกัน 25 ไบต์ แต่สำหรับ python3.6 +: lambda b:f'{bool(b):032}'หรือlambda b:f'{not b<1:032}'
Felipe Nardi Batista

1
คุณสามารถบันทึก 1 ไบต์โดยการลบศูนย์นำ0.32dหน้า
GarethPW

9

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



7

Javascript, 23 ไบต์

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

!!a บีบบังคับ a เป็นบูลีนซึ่ง unary plus เปลี่ยนเป็น int


a=>'0'.repeat(31)+(+a)สั้นลงหนึ่งไบต์
Kritixi Lithos

@Cowsquack ที่ล้มเหลวในสตริง, อาร์เรย์ว่าง, NaN, ฟังก์ชั่นและค่าอื่น ๆ ที่การบีบบังคับเป็นตัวเลขไม่ส่งผลให้ 0 หรือ 1
SuperStormer

นอกจากนี้ยังมีวัตถุว่างอาร์เรย์อินฟินิตี้และไม่ได้กำหนด
SuperStormer

1
... แต่ตอนนี้ ...Your program doesn't have to work for every truthy/falsy type, only what your programming language work best for.
edc65

1
a=>'0'.repeat(31)+~~aทำงานได้จริง, เท็จ, 1,0
edc65


5

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


5 ไบต์ -ᛝΨβ_I
Okx

ไม่ได้อยู่บนวิกิคุณพบมันที่ไหน
LiefdeWen

1
มันอยู่ในรายการตัวแปร
Okx

@ okx โอเคขอบคุณสำหรับเคล็ดลับ
LiefdeWen


4

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

ลองออนไลน์!


2
ยินดีต้อนรับสู่ PPCG!
Stephen

4

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.

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

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


ขอบคุณเอนโทรปีฉันทำให้มันสั้นลง 1 ไบต์เพื่อไปยังหมายเลข 16
RaphaëlCôté

เพื่อความสนุกนี่คือรุ่น 60 ไบต์: >-[-[-<]>>+<]>--<<-[>+<-----]>--->[-<.>],.(รับอินพุตเป็น 0 หรือ 1) ลองใช้ออนไลน์!
Graviton

ขอบคุณมาก @ Graviton คุณทำให้ฉันรู้ว่าฉันใช้ความพยายามมากเกินไปในการลดค่า ASCII เป็น 0 ในขณะที่ฉันเพิ่งจะเอาท์พุท
RaphaëlCôté

3

สกาลา, 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

ลองออนไลน์!


3

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

นี่คือลิงค์ของ tio ที่มีตัวอักษร 0x1F อยู่ในนั้นTIO
PunPun1000

@ PunPun1000 โอ้ขอบคุณ! ฉันจะอัปเดตโพสต์
Skidsdev

2

อ็อกเทฟ 23 ไบต์

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

ลองออนไลน์!

นี่สั้นกว่าวิธีที่ฉันลองด้วยprintfทั้งหมด ฉันอาจจะพลาดบางสิ่งบางอย่างตั้งแต่ทำในโทรศัพท์ของฉัน

อีกหนึ่งไบต์เท่านั้น

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

นี่อาจเป็น 18 ไบต์ถ้าฉันสามารถใช้ 1/0 เป็นสตริงได้

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

ลองออนไลน์!


2

Java 8, 31 27 ไบต์

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

-4 ไบต์ขอบคุณที่@ OlivierGrégoire

ลองที่นี่


1
ยังอยู่ที่นี่เพื่อเอาชนะคุณ: "".format;)
Olivier Grégoire

1
@ OlivierGrégoireนั่นแหล่ะ! ประณามฉันโง่ .. xD เมื่อฉันพิมพ์String.formatฉันรู้ว่ามีวิธีที่สั้นกว่าอย่างใด แต่ฉันคิดว่าฉันอาจจะใช้ตัวแปร String ครั้งสุดท้าย ... ขอบคุณ ;)
Kevin Cruijssen


2

ทับทิม 21 ไบต์

ใช่พื้นที่นั้นต้องอยู่ที่นั่น .. : /

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

ในทับทิมทุกอย่างยกเว้นfalseและnilเป็นความจริง ลองออนไลน์!



1

ถ่าน 5 ไบต์

×0³¹S

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

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


: P ถูกต้องจริงฉันคิดว่าฉันทำตัวแปรเป็นสตริงTrueถึงแปลก
เท่านั้น

1

Python 2 , 26 25 ไบต์

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

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

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

ลองออนไลน์!


แทนที่~~ด้วย+สำหรับ -1 หลังจากนั้นโปรแกรมเต็มรูปแบบจะไม่ได้มีราคาแพงอีกต่อไป ;)
Erik the Outgolfer

@EriktheOutgolfer ฉันไม่รู้ว่ามันเป็นไปได้ขอบคุณ!
Adnan


1

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");
}


1

PHP, 28 ไบต์

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

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

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

สั้นลง 3 ไบต์: printf('%032d',$argv[1]);(ต้องมีการ-rตั้งค่าสถานะ)
user63956

1

Ly , 20 15 13 ไบต์

65*1+[0u1-]nu

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


จะ65*1+["0"o1-]nuทำงานอย่างไร
OVS

1

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

@(x)x(1:32)

ลองออนไลน์!

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

คำอธิบาย:

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


1

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 อยู่แล้วซึ่งสั้นกว่าคำตอบนี้ แต่ก็ยัง :)


ใช่returnคำสั่งเป็นส่วนหนึ่งของรหัสของคุณดังนั้นเป็นส่วนหนึ่งของการนับไบต์ของคุณ แต่คำตอบของคุณไม่เป็นไปตามกฎ: คุณต้องได้รับbooleanเป็นอินพุต "Truthy / falsy" จะแปลในชวาเป็นอย่างใดอย่างหนึ่งtrueหรือfalseและไม่มีอะไรอื่น ดังนั้นคุณไม่สามารถรับStringพารามิเตอร์อินพุตได้
Olivier Grégoire

ฉันเห็น. ฉันจะแก้ไขมันเร็วพอ ขอบคุณ
V. Courtois

1
คุณไม่จำเป็นต้องใส่เครื่องหมายอัฒภาคสุดท้าย ( ;) c->{String k="";for(;k.length()<31;)k+=0;return k+=c?1:0;}นอกจากนี้คุณยังสามารถร่นรหัสของคุณเช่นนี้ คือการร่นk+=c?1:0 k+(c?1:0)
Olivier Grégoire

@ OlivierGrégoireขอบคุณ แต่ทำไมไม่ใช้เครื่องหมายอัฒภาคสุดท้าย?
V. Courtois

1
มันเป็นข้อบังคับในรหัส แต่ไม่ใช่ในตัวอย่าง ใน TIO ;ส่วนท้ายก็สามารถเริ่มต้นด้วย คำสั่งต้องมีเครื่องหมายอัฒภาค แลมบ์ดาไม่ใช่คำแถลง
Olivier Grégoire

1

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 ในตัว(2 ไบต์)


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

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

ลองออนไลน์!

ชุดทดสอบ


1

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

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

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

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

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

ลองออนไลน์!


1
ฉันไม่คิดว่าอันที่สองใช้ได้ จำนวนเต็มไม่ใช่ความจริงหรือเท็จใน C # มีเพียงคนโง่เท่านั้น
Skidsdev

@Mayube ฉันถามแล้ว OP บอกว่าใช้ได้ แต่ฉันก็เห็นด้วยกับคุณดังนั้นจะแก้ไข
LiefdeWen

1
น่ารำคาญPadleftมาที่ไบต์เดียวกันนับที่นี่
TheLethalCoder

@TheLethalCoder เริ่มต้นด้วย PadLeft เช่นกัน :)
LiefdeWen

2
ไม่แน่ใจว่าเป็นไปได้หรือไม่ แต่interpolated stringsมีประโยชน์มากที่นี่:b=>$"{(b?1:0):D32}" 19 bytes
auhmaan

1

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


0

APL ขนาด 11 ไบต์

⍕¯32↑1↑1\⍨⊢

อย่างไร?

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

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

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

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


เพียงแค่⍕¯32↑⊢ควรจะทำงาน
Kritixi Lithos

1
@Cowsquack & Uriel ไม่ทำงานเนื่องจากมีช่องว่าง คุณต้องการ∊⍕¨¯32↑⎕หรืออะไร
Adám

0

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


ฉันเข้าใจว่า 1 และ 0 เป็น booleans ใน J แต่คุณแค่ต่อท้ายอินพุตกับ 31 0s ไม่ควรมีการตรวจสอบบูลีนในบางรูปแบบ?
โอลิเวอร์

@Oliver ปัญหาระบุ "ให้ค่าความจริง / ความเท็จ ... " ดังนั้นไม่ฉันไม่คิดว่าคุณควรจะตรวจสอบ ... นอกจากนี้โปรดทราบว่า":สิ่งนี้จำเป็นสำหรับการทำงาน - มันเปลี่ยนบูลีนเป็นสตริง .
Jonah
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.