परिचय

शास्त्रीय रूप से, बूलियन एक बिट हैं; trueया false, 1या 0। अग्रणी शून्य सिर्फ निरर्थक होगा। उदाहरण के लिए, 001इसका मतलब है कि 00001सिर्फ या सिर्फ 1।

32-बिट बूलियन

एक सत्य / गलत मूल्य को देखते हुए, एक स्ट्रिंग के रूप में बराबर 32-बिट बूलियन का उत्पादन करें। (या एक संख्या के रूप में अगर किसी कारण से आपकी भाषा अग्रणी शून्य का समर्थन करती है।)

आपके प्रोग्राम को हर सत्य / झूठे प्रकार के लिए काम नहीं करना पड़ता है, केवल वही आपकी प्रोग्रामिंग भाषा सबसे अच्छा काम करती है।

उदाहरण i / o

Input >> Output

truthy >> 00000000000000000000000000000001
falsey >> 00000000000000000000000000000000

यह कोड-गोल्फ है , इसलिए सबसे कम बाइट्स जीतती हैं!

code-golf string

— Graviton
स्रोत

6

क्या हमें किसी भी संभावित सत्य या गलत मूल्य, या सिर्फ बूलियंस को संभालने की आवश्यकता है?

— xnor

यदि मेरी भाषा प्रकारों का समर्थन करती है और बूलियन है, तो क्या मैं सत्य के रूप में 1 (int) का उपयोग कर सकता हूं?

— लीफडेविन

निश्चित रूप से @LiefdeWen

— Graviton

1

सत्य / झूठे इनपुट के रूप में अब कोई डुप्लिकेट नहीं है, प्रत्येक उत्तर / भाषा के लिए भिन्न नहीं हो सकता है।

— ग्रेविटन

मैं नहीं देखता, लेकिन हुह, ठीक है ~

— वी। कोर्टोइस

10

पायथन 3 , 33 25 18 15 बाइट्स

धन्यवाद @ jurjen- बोस __mod__टिप के लिए।

'%.32d'.__mod__

इसे ऑनलाइन आज़माएं!

— wrymug
स्रोत

चाहेंगे lambda b:'%0.32d'%bकाम करते हैं?

— ბიმო

ओह, None सत्य है या मिथ्या है ?

— ბიმო

@ ब्रूसफोर्ट फ़ासी

— wrymug

1

25 बाइट्स भी, लेकिन python3.6 + के लिए: lambda b:f'{bool(b):032}'याlambda b:f'{not b<1:032}'

— फेलिप

1

आप अग्रणी शून्य को हटाकर 1 बाइट बचा सकते हैं 0.32d।

— GarethPW

9

x86-16 मशीन कोड (डॉस), 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

उपरोक्त फ़ंक्शन को BLरजिस्टर (कम बाइट ) में बूलियन मान (0 == फाल्सी, 1 == सत्य BX) प्राप्त होता है, और मानक आउटपुट के लिए "अनावश्यक बूलियन" स्ट्रिंग प्रिंट करता है।

यह एक डॉस फ़ंक्शन कॉल करने के लिए एक व्यवधान (0x21) को आमंत्रित करके काम करता है ( मानक AH2 से चयनित ) जो DLमानक आउटपुट में एक एकल वर्ण (में ) प्रिंट करता है ।

सबसे पहले, ASCII वर्ण '0' में लोड किया गया है DL, काउंटर ( CX) 31 पर सेट है, और यह "निरर्थक" बाइट्स को प्रिंट करने के लिए लूप करता है। फिर, बूलियन मान में जोड़ा जाता है DL(यदि BLfalsey है, 0 जोड़ने छोड़ देंगे DLASCII '0' के रूप में कोई बदलाव नहीं है, अगर BLtruthy है, DLASCII '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निर्देश (पेंटियम से पहले एक undocumented opcode, के बराबर है sbb al, al, लेकिन 2 के बजाय केवल 1 बाइट) AL0 पर सेट होता है यदि दो मान समान थे, या -1 यदि वे अलग-अलग थे। यह तब स्पष्ट है कि जब हम इससे घटाते ALहैं DL, तो यह ASCII '0' या '1' के रूप में उपयुक्त होता है।

(ध्यान दें, कुछ विडंबना यह है कि आप इसे तोड़ देंगे यदि आप कमांड लाइन पर एक अग्रणी 0 के साथ एक तर्क पास करते हैं, क्योंकि यह केवल पहले वर्ण पर दिखता है। इसलिए 01इसे गलत माना जाएगा। :-)

— कोडी ग्रे
स्रोत

8

पायथन 3 , 23 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— C मैकआवॉय
स्रोत

8

'10'[not n]यदि उनका समर्थन करने की आवश्यकता होगी तो पर्याप्त होगा।

— एंडर्स कासोर्ग

'{:032}'.format15 बाइट्स के लिए और अपने वर्तमान समाधान के समान काम करें

— फेलिप नारदी बतिस्ता

@rosslh bool(n)पर्याप्त होगा

— फेलिप

7

जावास्क्रिप्ट, 23 बाइट्स

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

!!a एक बूलियन में coerces, जो कि यूनरी प्लस एक इंट में बदल जाता है।

— SuperStormer
स्रोत

a=>'0'.repeat(31)+(+a)एक बाइट कम है

— कृति लिथोस

@Cowsquack जो स्ट्रिंग्स, खाली सरणियों, NaN, फ़ंक्शंस और अन्य मानों पर विफल रहता है, जहां संख्या में

— बलपूर्वक

खाली वस्तुओं, सरणियों, अनंत और अपरिभाषित

— सुपरस्टॉर्मर

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

6

वी , 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

— DJMcMayhem
स्रोत

5

नीम , 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 के लिए धन्यवाद बाइट सहेजा गया

— LiefdeWen
स्रोत

५ बाइट्स -ᛝΨβ_I

— १३:३३ पर ओकेक्स

ᛝविकी पर नहीं है, आपको यह कहां से मिला?

— LiefdeWen

1

यह चर

— ओकेक्स

@ ओकेक्स ठीक है, टिप के लिए धन्यवाद।

— लिफडेविन

4

ऑक्टेव , 17 बाइट्स

@(n)dec2bin(n,32)

अनाम फ़ंक्शन। MATLAB में भी काम करता है।

इसे ऑनलाइन आज़माएं!

— लुइस मेंडो
स्रोत

1

मैं अभिशप्त हो जाऊंगा ...

— स्टीवी ग्रिफ़िन

4

अर्नोल्ड , 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

इसे ऑनलाइन आज़माएं!

— TemporalWolf
स्रोत

2

PPCG में आपका स्वागत है!

— स्टीफन

4

ब्रेनफक , 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.

पहले गोल्फ के लिए मजेदार था!

~~अब बहुत देर हो चुकी है।~~ मैं भी क्या कर रहा हूँ

— राफेल कोट
स्रोत

एंट्रोपी की बदौलत, मैंने 16 नंबर पर पहुंचने के लिए इसे 1 बाइट से छोटा कर दिया।

— राफेल कोट

बस यहाँ एक 60 बाइट संस्करण मज़ा के लिए: >-[-[-<]>>+<]>--<<-[>+<-----]>--->[-<.>],.(0 या 1 के रूप में इनपुट लेता है) यह ऑनलाइन कोशिश करो!

— ग्रेविटन

खैर, बहुत बहुत धन्यवाद @Graviton। आपने मुझे महसूस कराया कि मैं ASCII मान को गिराने के लिए बहुत अधिक प्रयास कर रहा था, जबकि मुझे अभी इसका उत्पादन करना था।

— राफेल कोट

3

स्काला, 32 बाइट्स

क्षमा करें, लेकिन मुझे इसे 32 बाइट्स> _ <में करने के लिए मजबूर किया गया था

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

यह एक फ़ंक्शन द्वारा tपैरामीटर के रूप में संलग्न है (जो stringकि सम्मान के लिए "0" या "1" हो सकता है। मिथ्या या सत्य), और sवापस आ गया है।

यह ऑनलाइन की कोशिश करो!

मान्य प्रतिक्रिया: स्काला, 46 बाइट्स

मेरी जावा प्रतिक्रिया के समान, मुझे पैरामीटर के लिए बूलियन लेना था। इसलिए :

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

यह ऑनलाइन की कोशिश करो!

— वी। कोर्टीस
स्रोत

3

ब्रिंगोल्फ , 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

— Skidsdev
स्रोत

यहाँ 0x1F चरित्र के साथ tio लिंक है इसमें TIO

— PunPun1000

@ PunPun1000 ओह धन्यवाद! मैं पोस्ट को अद्यतन

— करूंगा

2

ऑक्टेव , 23 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह उन सभी तरीकों से छोटा है, जिनके साथ मैंने कोशिश की थी printf। मुझे कुछ याद हो सकता है, क्योंकि मैंने अपने फोन पर ऐसा किया है।

केवल एक बाइट लंबे समय तक

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

यह 18 बाइट्स हो सकता है अगर मैं स्ट्रिंग्स के रूप में 1/0 ले सकता हूं।

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

इसे ऑनलाइन आज़माएं!

— स्टीवी ग्रिफिन
स्रोत

2

जावा 8, 31 27 बाइट्स

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

-4 बाइट्स का धन्यवाद @ ओलिवियरग्रेगायर ।

इसे यहाँ आज़माएँ।

— केविन क्रूज़सेन
स्रोत

1

हाँ, अभी भी यहाँ आप outgolf करने के लिए "".format;)

— Olivier Grégoire

1

@ OlivierGrégoire यही था! धिक्कार है कि मैं बेवकूफ हूँ .. जब मैं टाइप कर String.formatरहा था तो मुझे पता था कि किसी तरह एक छोटा रास्ता था, लेकिन मुझे लगा कि मैंने शायद पिछली बार एक स्ट्रिंग चर का इस्तेमाल किया था ... धन्यवाद। ;)

— केविन क्रूज़सेन

2

05AB1E , 5 बाइट्स

¾31×«

इसे ऑनलाइन आज़माएं!

— Okx
स्रोत

होशियार से 31úð0:!

— मैजिक ऑक्टोपस Urn

2

रूबी, 21 बाइट्स

हाँ, उस जगह की जरूरत है ..: /

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

रूबी में सब कुछ छोड़कर falseऔर nilसत्य है; इसे ऑनलाइन आज़माएं!

— daniero
स्रोत

1

गणितज्ञ, 36 बाइट्स

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

गणितज्ञ, 26 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— J42161217
स्रोत

1

चारकोल , 5 बाइट्स

×0³¹Ｓ

इसे ऑनलाइन आज़माएं! (क्रिया संस्करण से लिंक करें।)

चारकोल को समझने के रूप में 0और 1के रूप में Trueया False, यह सिर्फ 31 प्रिंट 0और इनपुट ( 0या 1) स्ट्रिंग के रूप में।

— चार्ली
स्रोत

: P यह वास्तव में सही है , मुझे लगा कि मैंने चर को Trueअजीब बना दिया है , अजीब है

— ASCII-only

1

पायथन 2 , 26 25 बाइट्स

एक बाइट को बचाने के लिए आउटगोफ़र के लिए धन्यवाद !

पूर्ण कार्यक्रम दृष्टिकोण के लिए जाता है:

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

इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

बदलें ~~के साथ +के लिए -1। उसके बाद पूरा कार्यक्रम अब महंगा नहीं होगा । ;)

— एरिक आउटगॉल्फ

@EriktheOutgolfer मुझे नहीं पता था कि यह संभव था, धन्यवाद!

— अदनान

1

अवांछित, अनावश्यक, अवसरवादी , 7 बाइट्स

P0M31P*

रजिस्टर में 1 या 0 पास करें।

— फासो
स्रोत

1

सी, 26 बाइट्स

बहुत सुंदर 1bluestone समाधान के रूप में एक ही विचार है , लेकिन सी में यह छोटा है, और यह किसी भी पूर्णांक इनपुट के लिए सही ढंग से काम करता है:

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

बेशक, इसमें कुछ अच्छे टाइप किए गए चर / फ़ंक्शन शामिल हैं, जैसा कि सभी अच्छे सी-गोल्फ उत्तर करते हैं ... !!ऑपरेटर 1सी में किसी भी सत्य मान को बदलने का सबसे छोटा तरीका है (डबल नकार के माध्यम से, !या तो लौटने के लिए परिभाषित किया गया है)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");
}

— cmaster - पुनः स्थापित मोनिका
स्रोत

1

हास्केल , 37 32 बाइट्स

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

इसे ऑनलाइन आज़माएं!

धन्यवाद @nimi -5बाइट्स के लिए!

— ბიმო
स्रोत

2

show(fromEnum x)के बजाय last(...)। पॉइंटफ़्री और भी छोटा (('0'<$[1..31])++).show.fromEnum:।

— निम्मी

@nimi पता नहीं था कि Boolएक है Enum, धन्यवाद!

— ბიმო

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

लाइ , 20 15 13 बाइट्स

65*1+[0u1-]nu

संपादित करें: 5 बाइट्स ओव्स के लिए धन्यवाद।
संपादित करें: 0 को एक वर्ण के बजाय संख्या के रूप में मुद्रित करके 2 अन्य बाइट्स सहेजे गए।

— LyricLy
स्रोत

चाहेंगे 65*1+["0"o1-]nuकाम करते हैं?

— अंडा

1

ऑक्टेव, 16 11 बाइट्स

@(x)x(1:32)

इसे ऑनलाइन आज़माएं!

एक फ़ंक्शन हैंडल जो "00000000000000000000000000000001"सत्य के रूप में लेता है और "00000000000000000000000000000000\0" सत्य के रूप में मिथ्या के रूप में लेता है।

स्पष्टीकरण:

ऑक्टेव में एक सरणी को गलत माना जाता है यदि इसका कम से कम एक तत्व शून्य है। दूसरे तार का 33 वां तत्व 0 के ASCII मूल्य के साथ एक चरित्र है, इसलिए इसे गलत माना जा सकता है।

— rahnema1
स्रोत

1

जावा, 40 चार्ट, 40 बाइट्स

यह स्ट्रिंग को पैरामीटर के रूप में लेता है, जो सही नहीं है (ओपी द्वारा एक मूर्खता का प्रतिनिधित्व करने के लिए गलत / सत्य जावा मूल्य को मजबूर किया गया है)।

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

यह ऑनलाइन की कोशिश करो!

मान्य प्रतिक्रिया: जावा, 60 चार्ट, 60 बाइट्स

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

यह ऑनलाइन की कोशिश करो!

मुझे पता है कि पहले से ही एक जावा उत्तर है जो इस एक से छोटा है, लेकिन फिर भी :)

— वी। कोर्टीस
स्रोत

हां, returnस्टेटमेंट आपके कोड का हिस्सा है, इसलिए आपकी बाइट-काउंट का हिस्सा है। लेकिन आपका जवाब नियमों को पूरा नहीं करता है: आपको एक इनपुट मिलना चाहिएboolean । "Truthy / falsy" के रूप में या तो जावा में अनुवाद किया है trueया false, और कुछ नहीं। इसलिए आपको Stringइनपुट पैरामीटर के रूप में नहीं मिल सकता है ।

— ओलिवियर ग्राएगोइरे

समझा। मैं इसे जल्द ही संशोधित करूंगा। धन्यवाद।

— वी। कोर्टोइस

1

आपको अंतिम अर्धविराम ( ;) लगाने की आवश्यकता नहीं है । इसके अलावा, आप अपने कोड को इस तरह छोटा कर सकते हैं c->{String k="";for(;k.length()<31;)k+=0;return k+=c?1:0;}:। k+=c?1:0छोटा करने के लिए है k+(c?1:0)।

— ओलिवियर ग्रैगोइरे

@ OlivierGrégoire धन्यवाद, लेकिन अंतिम अर्धविराम अनिवार्य क्यों नहीं है?

— वी। कोर्टोइस

1

यह कोड में अनिवार्य है, लेकिन स्निपेट में नहीं। TIO में, पाद के साथ बस शुरू कर सकते हैं ;। एक बयान के लिए अर्धविराम की आवश्यकता होती है। एक लंबोदर एक बयान नहीं है।

— ओलिवियर ग्राएगोयर

1

जाप , 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 रूपांतरण बिल्ट-इन का उपयोग करके एक बाइट को बचाया!

1/ के सामने 0s की स्ट्रिंग सम्मिलित करने के लिए 0, मुझे 1और 0स्ट्रिंग में डालने की आवश्यकता है । ऐसा करने का विशिष्ट तरीका 1s (3 बाइट्स) होगा। लेकिन क्योंकि हम केवल 1s और 0s को परिवर्तित कर रहे हैं, मैं बेस -2 अंतर्निहित 1¤(2 बाइट्स) का उपयोग कर सकता हूं ।

इनपुट पूर्णांक या स्ट्रिंग के रूप में हो सकता है।

0और ""जाप में मिथ्या हैं।

इसे ऑनलाइन आज़माएं!

परीक्षण सूट

— ओलिवर
स्रोत

1

सी # (.NET कोर) , 29 बाइट्स

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

ओपी ने कहा कि 1/0 का इस्तेमाल सत्य / फालसे के लिए किया जा सकता है, इसलिए यह aएक अंतर बना सकता है और यह बन जाता है

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

सी # में वास्तव में सच्चाई / गलत नहीं है, हालांकि मैं इस उत्तर का उपयोग नहीं करूंगा।

इसे ऑनलाइन आज़माएं!

— LiefdeWen
स्रोत

1

मुझे नहीं लगता कि दूसरा वैध है। इंजीर्स न तो सत्य हैं और न ही C # में गलत हैं, केवल बूल हैं।

— स्काइड्सदेव

@ माय्यूब ने मुझसे पूछा और ओपी ने कहा कि ठीक है, लेकिन मैं थोड़े सहमत हूं कि आप इसे संपादित करेंगे।

— LiefdeWen

1

Annoyingly Padleftएक ही बाइट पर में आता है यहाँ गिनती।

— TheLethalCoder

@LethalCoder ने 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)

मैं विश्वास नहीं कर सकता कि यह किसी भी दो-तर्क के बिना संभव है जो भी हो!

संपादित करें: 31 प्राप्त करने के लिए अंकगणित के बजाय primes का उपयोग करके 1 बाइट को बचाया।

— जाकारी
स्रोत

0

एपीएल, 11 बाइट्स

⍕¯32↑1↑1\⍨⊢

कैसे?

1\⍨⊢ - 1 इनपुट बार दोहराएं - मिथ्या मान पर खाली सरणी लौटाएं

1↑ - पहले आइटम ले लो

¯32↑ - 31 शून्य के साथ सही संरेखित करें

⍕ - स्ट्रिंग के रूप में प्रारूप

— Uriel
स्रोत

बस ⍕¯32↑⊢काम करना चाहिए

— क्रिति लिथोस

1

@Cowsquack और Uriel न तो काम करता है क्योंकि वे रिक्त स्थान शामिल हैं। आपको जरूरत है ∊⍕¨¯32↑⎕या कुछ और।

— एडम जूल 19'17

0

जे, 11 बाइट्स

(31#'0'),":

इसे ऑनलाइन आज़माएं!

कैसे?

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

ध्यान दें: जे में, बूलियन 0 या 1 होते हैं, जिन्हें "आइवरसन कन्वेंशन" के रूप में भी जाना जाता है, केन आइवरसन के बाद, जे और एपीएल के निर्माता।

— जोनाह
स्रोत

मैं समझता हूं कि J में 1 और 0 बूलियन हैं, लेकिन आप सिर्फ इनपुट को 31 0s में जोड़ रहे हैं। क्या बूलियन सत्यापन का कोई रूप नहीं होना चाहिए?

— ओलिवर

@ ओलिवर समस्या निर्दिष्ट करता है "एक सत्य / गलत मूल्य को देखते हुए ..." नहीं, तो मुझे नहीं लगता कि आपको मान्य होना चाहिए ... इसके अलावा, ध्यान दें कि इसके ":लिए काम करना आवश्यक है - यह एक बूलियन को एक स्ट्रिंग में बदलता है। ।

— जोनाह

निरर्थक बूलियन

परिचय

32-बिट बूलियन

उदाहरण i / o

यह कोड-गोल्फ है , इसलिए सबसे कम बाइट्स जीतती हैं!

पायथन 3 , 33 25 18 15 बाइट्स

x86-16 मशीन कोड (डॉस), 16 बाइट्स

पूर्ण कार्यक्रम, 21 बाइट्स

पायथन 3 , 23 बाइट्स

जावास्क्रिप्ट, 23 बाइट्स

वी , 8 बाइट्स

नीम , 6 5 बाइट्स

ऑक्टेव , 17 बाइट्स

अर्नोल्ड , 369 बाइट्स

ब्रेनफक , 61 60 36 बाइट्स

स्काला, 32 बाइट्स

मान्य प्रतिक्रिया: स्काला, 46 बाइट्स

ब्रिंगोल्फ , 10 8 बाइट्स

व्याख्या

ऑक्टेव , 23 बाइट्स

जावा 8, 31 27 बाइट्स

05AB1E , 5 बाइट्स

रूबी, 21 बाइट्स

गणितज्ञ, 36 बाइट्स

गणितज्ञ, 26 बाइट्स

चारकोल , 5 बाइट्स

पायथन 2 , 26 25 बाइट्स

अवांछित, अनावश्यक, अवसरवादी , 7 बाइट्स

सी, 26 बाइट्स

हास्केल , 37 32 बाइट्स

PHP, 28 बाइट्स

लाइ , 20 15 13 बाइट्स

ऑक्टेव, 16 11 बाइट्स

जावा, 40 चार्ट, 40 बाइट्स

मान्य प्रतिक्रिया: जावा, 60 चार्ट, 60 बाइट्स

जाप , 13 11 बाइट्स

स्पष्टीकरण:

सी # (.NET कोर) , 29 बाइट्स

MY , 10 9 बाइट्स

एपीएल, 11 बाइट्स

जे, 11 बाइट्स

कैसे?