दोहरावदार बाइट काउंटर


19

आपका कार्य बाइट काउंट L के एक गैर-खाली प्रोग्राम / फ़ंक्शन को लिखना है , जो, जब एम बार दोहराया जाता है, तो यह जांचता है कि क्या दिया गया सकारात्मक पूर्णांक N , L × M के बराबर है ।

आपको सिद्धांत रूप में, मनमानी संख्या का दोहराव ( M का एक मनमाना धनात्मक पूर्णांक मान ) का समर्थन करना चाहिए, लेकिन यह ठीक है अगर, भाषा सीमाओं के कारण, यह एक निश्चित सीमा से अधिक काम नहीं कर सकता है। अपने कार्यक्रम के स्रोत कोड को पढ़ना या इसके बारे में जानकारी तक पहुंचना सख्त वर्जित है

आउटपुट प्रदान करने के लिए, आपको किसी एक राज्य (या तो सत्य या मिथ्या) के लिए एक सुसंगत मूल्य चुनना चाहिए और दूसरे राज्य ( चर्चा ) के लिए किसी अन्य (आवश्यक रूप से सुसंगत) संभव आउटपुट का उपयोग नहीं करना चाहिए ।

आपके उत्तर आपके प्रारंभिक कार्यक्रम की लंबाई L (बाइट्स में) द्वारा बनाए जाएंगे , कम बाइट्स बेहतर होने के साथ।

उदाहरण

मान लें कि आपका (प्रारंभिक) प्रोग्राम है ABCDE। फिर:

  • ABCDE(1 पुनरावृत्ति) यह देखना चाहिए कि इनपुट 5 के बराबर है या नहीं ।
  • ABCDEABCDE(2 दोहराव) को जांचना चाहिए कि इनपुट 10 के बराबर है या नहीं ।
  • ABCDEABCDEABCDE(3 पुनरावृत्ति) को जांचना चाहिए कि इनपुट 15 के बराबर है या नहीं । आदि...

इस नमूना कोड का स्कोर 5 होगा , क्योंकि प्रारंभिक स्रोत 5 बाइट्स लंबा है।


बस स्पष्ट करने के लिए: अपने स्वयं के समय के बाद संक्षिप्त किए गए लंबाई के स्रोत कोड को वापस करना चाहिए कि क्या इसके इनपुट के बराबर हैLMNL*M ?

जवाबों:


12

जेली , 1 बाइट

एक मैच के लिए आउटपुट 0 है , एक गैर-मैच के लिए गैर-शून्य है।

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

यह काम किस प्रकार करता है

यह अत्यधिक उदार आउटपुट प्रारूप का लाभ उठाता है। एम बार दोहराने से केवल इनपुट एम बार में कमी आती है , इसलिए परिणाम शून्य होगा और केवल अगर इनपुट एलएम है , जहां एल = 1


हे भगवान मैंने यह नहीं देखा ... ( inb4 हर कोई इसे अन्य esolangs के लिए पोर्ट करता है ... )
श्री Xcoder

मेरे पास 0-बाइट का जवाब दिमाग में था, लेकिन, एह, क्वीन । : पी
एरिक आउटगोल्फर

मेरा पहला विचार। 23 मिनट से
हराया

11

हास्केल, 8 बाइट्स

(-8+).id

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

कई अन्य उत्तरों की तरह यह सत्य और गैर-0 के लिए 0 रिटर्न देता है, बार-बार इनपुट नंबर से कोड की लंबाई घटाकर झूठे के लिए।


मैं था तो इस के लिए हो रही करने के लिए संवारता के करीब ...
totallyhuman

8

रेटिना , 21 20 बाइट्स

\d+
*
^$
_
^_{20}

_

इसे ऑनलाइन आज़माएं! कोड विंडो में भाग को केवल यह देखने के लिए दोहराएं कि यह गुणकों को कैसे संभालता है।

देता है 0और सब कुछ के लिए सही कई और धनात्मक पूर्णांक के लिए।

व्याख्या

आइए पहले कार्यक्रम को देखें:

\d+
*

यह एक दशमलव संख्या को unary में बदलता है ( _unary अंक के रूप में उपयोग करते हुए )।

^$
_

यदि स्ट्रिंग खाली है (जो इस बिंदु पर नहीं हो सकती है, क्योंकि इनपुट सकारात्मक होने की गारंटी है), हम इसे एक के साथ बदलते हैं _

^_{20}

अब हम पहले 20 अंडरस्कोर से छुटकारा पा लेते हैं। Iff इनपुट था 20, यह एक रिक्त स्ट्रिंग में परिणाम है।

_

और अंत में हम परिणाम में अंडरस्कोर की संख्या की गणना करते हैं, जो कि इनपुट के अनुसार शून्य शून्य है 20


अब क्या होता है जब हम स्रोत कोड दोहराते हैं। चूँकि हम प्रोग्राम्स में शामिल होने के दौरान एक लाइनफीड नहीं डालते हैं, पहली लाइन अंतिम लाइन के अंत में जाएगी, हमें यह तब मिलता है जब प्रोग्राम डबल हो जाता है:

\d+
*
^$
_
^_{20}

_\d+
*
^$
_
^_{20}

_

अब अंडरस्कोर गिनने के बजाय, हम निम्नलिखित चरण को समाप्त करते हैं:

_\d+
*

यह चरण कुछ भी नहीं करता है, क्योंकि इस बिंदु पर काम करने वाले स्ट्रिंग में अधिक अंक नहीं हैं, इसलिए रेगेक्स मेल नहीं खा सकता है।

^$
_

अब यह चरण प्रासंगिक हो गया है। यदि इनपुट 20 से छोटा था, तो स्रोत कोड की पिछली प्रतिलिपि द्वारा स्ट्रिंग खाली कर दी गई है। उस स्थिति में, हम इसे एक एकल अंडरस्कोर में बदल देते हैं, जिसे हम जानते हैं कि हमारे कार्यक्रम द्वारा फिर से एक खाली स्ट्रिंग में नहीं बदल सकता है। इस तरह हम देखते हैं कि यह सुनिश्चित केवल एम वें कई स्वीकार किया जाता है (और नहीं सब से ऊपर गुणकों एम वें)।

^_{20}

हम पहले 20 अंडरस्कोर को एक बार फिर हटा देते हैं। तो स्रोत कोड का M दोहराव संभव होने पर स्ट्रिंग से 20M अंडरस्कोर हटा देगा ।

_

और जब हम कार्यक्रम के अंत में पहुंचते हैं, तब भी हम अंडरस्कोर गिनते हैं ताकि मान्य इनपुट शून्य प्रदान करें।


6

x86 32-बिट मशीन कोड टुकड़ा, 1 बाइट

48                      dec    eax

EAX में इनपुट, EAX में आउटपुट: सच के लिए 0, झूठे के लिए गैर-शून्य। (यह भी सच है, झूठे के लिए परेशान है, तो आप कर सकते हैं के लिए ZF झंडा सेट छोड़ देता है je was_equal) एक "बोनस" के रूप में, आपको लपेटने के बारे में चिंता करने की ज़रूरत नहीं है; 32-बिट x 86 केवल मेमोरी के 4GiB को संबोधित कर सकता है, इसलिए आप M को पर्याप्त नहीं बना सकते हैं कि वह चारों ओर से घूम सके और 1 == 2**32 + 1कुछ न कुछ पा सके ।

कॉल करने योग्य फ़ंक्शन बनाने के लिए, M बार 0xC3 retदोहराने के बाद एक निर्देश संलग्न करें 0x48। (कुल गिनती में नहीं गिना जाता है, क्योंकि कई भाषाओं को केवल फ़ंक्शन बॉडी, या एक अभिव्यक्ति, प्रतिस्पर्धा करने में सक्षम होने के लिए दोहराने की आवश्यकता होती है)।

GNU C से प्रोटोटाइप __attribute__((regparm(1))) int checkeqM(int eax); GNU C की regparmx86 फ़ंक्शन विशेषता के साथ कॉल करने योग्य , जैसे -mregparm, पहले पूर्णांक arg पास करने के लिए EAX का उपयोग करता है।

उदाहरण के लिए, यह पूरा कार्यक्रम 2 आरजीएस लेता है, और जेआईटीएस एम निर्देश की प्रतियां + ए retएक बफर में, और फिर इसे फ़ंक्शन के रूप में बुलाता है। (निष्पादन योग्य ढेर की आवश्यकता है, के साथ संकलन gcc -O3 -m32 -z execstack)

/******* Test harness: JIT into a buffer and call it ******/
// compile with gcc -O3 -no-pie -fno-pie -m32 -z execstack
// or use mprotect or VirtualProtect instead of -z execstack
// or mmap(PROT_EXEC|PROT_READ|PROT_WRITE) instead of malloc

// declare a function pointer to a regparm=1 function
// The special calling convention applies to this function-pointer only
// So main() can still get its args properly, and call libc functions.
// unlike if you compile with -mregparm=1
typedef int __attribute__((regparm(1))) (*eax_arg_funcptr_t)(unsigned arg);

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

int main(int argc, char *argv[])
{
    if (argc<3) return -1;
    unsigned N=strtoul(argv[1], NULL, 0), M = strtoul(argv[2], NULL, 0);

    char *execbuf = malloc(M+1);   // no error checking
    memset(execbuf, 0x48, M);     // times M  dec eax
    execbuf[M] = 0xC3;            // ret
    // Tell GCC we're about to run this data as code.  x86 has coherent I-cache,
    // but this also stops optimization from removing these as dead stores.
    __builtin___clear_cache (execbuf, execbuf+M+1);
     //   asm("" ::: "memory");  // compiler memory barrier works too.

    eax_arg_funcptr_t execfunc = (eax_arg_funcptr_t) execbuf;
    int res = execfunc(N);
    printf("%u == %u  =>  %d\n", N,M, res );
    return !!res;   // exit status only takes the low 8 bits of return value
}

गैर- PIE निष्पादक आभासी मेमोरी में कम लोड किए जाते हैं; एक बड़ा सन्निहित मॉलोक कर सकता है।

$ gcc -g -O3 -m32 -no-pie -fno-pie -fno-plt -z execstack coderepeat-i386.c
$ time ./a.out 2747483748 2747483748   # 2^31 + 600000100 is close to as big as we can allocate successfully
2747483748 == 2747483748  =>  0

real    0m1.590s     # on a 3.9GHz Skylake with DDR4-2666
user    0m0.831s
sys     0m0.755s

$ echo $?
0

 # perf stat output:
       670,816      page-faults               #    0.418 M/sec                  
 6,235,285,157      cycles                    #    3.885 GHz                    
 5,370,142,756      instructions              #    0.86  insn per cycle         

ध्यान दें कि GNU सी का समर्थन नहीं करता वस्तु से भी बड़ा आकार ptrdiff_t(हस्ताक्षरित 32-बिट), लेकिन mallocऔर memsetअभी भी काम करते हैं, तो इस कार्यक्रम के सफल होता है।

एआरएम थम्ब मशीन कोड टुकड़ा, 2 बाइट्स

 3802            subs    r0, #2

पहले एआरएम इन r0और रिटर्न वैल्यू में r0मानक एआरएम कॉलिंग कन्वेंशन है। यह भी झंडे ( sप्रत्यय) सेट करता है । मजेदार तथ्य; गैर के -flag स्थापित संस्करण subएक 32-बिट विस्तृत अनुदेश है।

आपको जो निर्देश देने की आवश्यकता है वह रिटर्न निर्देश है bx lr

AArch64 मशीन कोड टुकड़ा, 4 बाइट्स

d1001000        sub     x0, x0, #0x4

64-बिट पूर्णांक के लिए काम करता है। इनपुट / आउटपुट x0मानक कॉलिंग कन्वेंशन के अनुसार। int64_t foo(uint64_t);

AArch64 में थम्ब मोड (अभी तक) नहीं है, इसलिए 1 निर्देश वह सर्वोत्तम है जो हम कर सकते हैं।


किसी और के लिए ध्यान दें जो इस पर आता है: कॉल __builtin___clear_cacheकेवल इसलिए आवश्यक है क्योंकि आप उस मेमोरी को निष्पादित कर रहे हैं जो आपको मिली थी malloc। यदि आपको mmapइसके बजाय मेमोरी मिली है , तो अनुकूलन नहीं होता है।
जोसेफ सिबल-पुनर्जित मोनिका

4

वी , 16 (या 1) बाइट्स

बोरिंग जवाब:

<C-x>

एक बाइट।

कम उबाऊ उत्तर:

uÓ^$/0
16Ø^a$

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

Hexdump:

00000000: 75d3 5e24 2f30 0a31 3601 d85e 1261 240a  u.^$/0.16..^.a$.

मैंने वास्तव में चुनौती सामने आने के 5 मिनट बाद यह लिखा था। स्पेगेटी कोड के इस भयानक ढेर को पैच करने के लिए मुझे 30 मिनट का समय लगा जिसे मैं एक भाषा कहता हूं ।





2

ब्रेन-फ्लैक , 24 बाइट्स

({}[(((()()()){}){}){}])

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

0बराबर के लिए रिटर्न और न के बराबर के लिए कुछ और।

यह काम किस प्रकार करता है:

({} #pop the top of the stack
  [(((()()()){}){}){}] #subtract 24
) #push the result.

यह कोड रन nबार n * 24इनपुट से घटाना होगा , जब इनपुट = केवल 0 देगा n*24



2

टीआई-बेसिक (83 श्रृंखला), 4 बाइट्स

:Ans-4

इसमें इनपुट लेता है Ans: उदाहरण के लिए, आप इसे 17:prgmCODEGOLFइनपुट के साथ चलाने के लिए टाइप कर सकते हैं 17। प्रिंट्स (और रिटर्न में Ans) वैल्यू 0यदि इनपुट L × M के बराबर है , और नॉनजरो वैल्यू अन्यथा।

ध्यान दें कि यह :कोड का हिस्सा है, इसलिए यदि आप इसे प्रोग्राम एडिटर में दर्ज कर रहे हैं, तो आपको देखना चाहिए

PROGRAM:CODEGOLF
::Ans-4

यदि आप इसे एक बार दर्ज करते हैं और

PROGRAM:CODEGOLF
::Ans-4:Ans-4:An
s-4

यदि आप इसे तीन बार दर्ज करते हैं।



1

Befunge-98 , 15 बाइट्स

]#<@.-&+
>fv
v+

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

इसे दोगुना करने की कोशिश करो!

समान के लिए 0 और असमान के लिए कुछ भी उपयोग करता है।

स्पष्टीकरण:

यह कोड कई बार दोहराया गया कुछ इस तरह दिखाई देगा:

]#<@.-&+
>fv
v+]#<@.-&+
>fv
v+]#<@.-&+
>fv
 .
 .
 .
v+]#<@.-&+
>fv
v+
  1. ]दायाँ मोड़। आईपी ​​को नीचे भेजता है।

  2. >पूर्व की ओर चलें। आईपी ​​सही भेजता है।

  3. f एक 16 धक्का।

  4. vदक्षिण की ओर चलें। आईपी ​​को नीचे भेजता है। अगर यह आखिरी बार है, तो गोटो 8 कदम।

  5. ]दायाँ मोड़। आईपी ​​छोड़ दिया है।

  6. +जोड़ें। स्टैक के शीर्ष पर 16 जोड़ता है।

  7. vदक्षिण की ओर चलें। आईपी ​​को नीचे भेजता है। गोटो स्टेप 2।

  8. <पश्चिम की ओर चलें। आईपी ​​छोड़ दो।

  9. #छोड़ें। ]अंत में कूदें और चारों ओर लपेटें।

  10. +जोड़ें। स्टैक के शीर्ष पर 16 जोड़ता है।

  11. &इनपुट। उपयोगकर्ता से एक नंबर पुश करें।

  12. -घटाना। उस राशि का अंतर प्राप्त करें जिस पर हम और इनपुट काम कर रहे थे।

  13. .मुद्रित करें। परिणाम प्रिंट करें।

  14. @ समाप्त।


1

शुद्ध बैश , १५

कमांड-लाइन पैरामीटर के रूप में दिया गया इनपुट। एक शेल निकास कोड के रूप में आउटपुट - 1TRUE के लिए और 0FALSE के लिए।

(((अ + = 15) - $ 1))


1

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

PI⁼Iθ×¹³L⊞Oυω

इसे ऑनलाइन आज़माएं! मैं स्रोत को दोगुना करने के अपने उत्तर के आधार पर , आप आउटपुट को दोगुना कर देता हूं! स्पष्टीकरण:

         ⊞Oυω   Push empty string to predefined empty list
        L       Take the length
     ×¹³        Multiply by 13
  ⁼Iθ           Compare to the input
 I              Cast to string
P               Print without moving the cursor

सत्य के लिए 1और मिथ्या के लिए आउटपुट का प्रबंधन करता है 0। इसके बाद पुनरावृत्ति के खिलाफ इनपुट तुलना 13, 26, 39, 52आदि लेकिन हर बार जवाब अधिमुद्रित है तो केवल अंतिम जवाब देखा जाता है।


1

जावास्क्रिप्ट ईएस 6, 32 बाइट्स

((f=k=>n=>n>0?n==k:f(k+32))(32))

अगर सच 0 हो और दूसरों की तरह झूठ हो, 31 बाइट्स

(f=k=>n=>n>0?n-k:_=>f(k+_))(31)

console.log([
    ((f=k=>n=>n>0?n==k:f(k+32))(32)) (31),
    ((f=k=>n=>n>0?n==k:f(k+32))(32)) (32),
    ((f=k=>n=>n>0?n==k:f(k+32))(32)) (33),
    ((f=k=>n=>n>0?n==k:f(k+32))(32)) (64),
    ((f=k=>n=>n>0?n==k:f(k+32))(32))((f=k=>n=>n>0?n==k:f(k+32))(32)) (32),
    ((f=k=>n=>n>0?n==k:f(k+32))(32))((f=k=>n=>n>0?n==k:f(k+32))(32)) (63),
    ((f=k=>n=>n>0?n==k:f(k+32))(32))((f=k=>n=>n>0?n==k:f(k+32))(32)) (64),
    ((f=k=>n=>n>0?n==k:f(k+32))(32))((f=k=>n=>n>0?n==k:f(k+32))(32))((f=k=>n=>n>0?n==k:f(k+32))(32)) (96)
]);


1

MIPS, 4 बाइट्स

$a0तर्क और वापसी मूल्य के रूप में उपयोग करता है ।

0x2084fffc    addi $a0, $a0, -4

MIPS, 8 बाइट्स (MIPS कॉलिंग कन्वेंशन का उपयोग करके)

0x2084fff8    addi $a0, $a0, -8
0x00041021    move $v0, $a0

x86, 5 बाइट्स

यह मेरा पहला x86 उत्तर है इसलिए प्रतिक्रिया का स्वागत है। पहले तर्क के रूप में ecx के साथ _fastcall सम्मेलन का उपयोग करता है।

83 e9 05                sub    $0x5,%ecx
89 c8                   mov    %ecx,%eax

पीटर कॉर्डेस की टिप्पणियों में 1 बाइट समाधान है।


ब्रेनफक कमेंट्री : एक एकल मूल्य वापस करने के लिए मुश्किल हिस्सा ब्रेनफक हो रहा है। अन्यथा ऐसा कुछ आसान होगा।

- >,[-<->] < .

1
आपका x86 कोड टुकड़ा 32-बिट पूर्णांक के लिए समान आकार का होगा, 8 तक सीमित करने की आवश्यकता नहीं है। लेकिन यदि आपने एक कस्टम कॉलिंग कन्वेंशन (एएल में एईजी, कहीं और फिर से बेचना) का उपयोग किया है, तो आप 2-बाइट का उपयोग कर सकते हैं विशेष एन्कोडिंग sub $4, %al/ mov %al, %dl। या अभी भी AL / EAX में लौटते हैं और फिर आपको डेनिस का समाधान मिलता है, dec %eax(32-बिट मोड में 1 बाइट) के साथ। और हाँ, कस्टम कॉलिंग कन्वेंशन asm के लिए ठीक हैं। यह asm है, न कि केवल "asm कि सी से कॉल करना आसान है"; asm में लिखा गया वास्तविक कोड कस्टम कॉलिंग सम्मेलनों का उपयोग करता है जहां यह मदद करता है, इसलिए यह पूरी तरह से उचित है।
पीटर कॉर्डेस

1
ARM का नॉर्मल कॉलिंग कन्वेंशन सबसे पहले arg होता है r0जिसमें रिटवल भी होता है, इसलिए Thumb sub r0, #22 बाइट्स है।
पीटर कॉर्ड्स

1
ध्यान दें कि इनमें से कोई भी कार्य नहीं हैं : retआपको उन्हें कॉल करने से पहले दोहराने ब्लॉक के अंत में आवश्यकता होती है । आम तौर पर मैं retअपने x86 asm उत्तरों के लिए बाइट काउंट में शामिल करता हूं। लेकिन मुझे लगता है कि यहाँ नियमों को झुकाने से सिर्फ फंक्शन बॉडी का ही अर्थ निकलता है, अन्यथा कई भाषाएं बिल्कुल भी प्रतिस्पर्धा नहीं कर सकती हैं।
पीटर कॉर्डेस

1
(एनवीएम, यह% अल में रिटेल को नहीं छोड़ता है)। xchg %eax, %ecx/ sub $4, %al/ xchg %eax, %ecx4 बाइट्स है, और _fastcall सम्मेलन का अनुसरण करता है। AL का उपयोग करते हुए, imm8 और xchg-with-eax शॉर्ट एनकोडिंग अक्सर कोड गोल्फ के लिए सहायक होते हैं।
पीटर कॉर्डेस

1
मैं आमतौर पर objdump -drwC -Mintelमशीन-कोड बाइट्स का एक हेक्सडंप प्राप्त करने के लिए उपयोग करता हूं। add r32, imm83 बाइट्स भी है: opcode + modR / M + imm8। सभी निर्देश जो एक imm32 ले सकते हैं उनके पास एक वैकल्पिक opcode है जो एक साइन-विस्तारित imm8 लेता है। उदाहरण के लिए felixcloutier.com/x86/ADD.html देखें ; 8086 से पहले के सभी "क्लासिक" ALU निर्देश (लेकिन MOV नहीं) में वे सभी एनकोडिंग हैं, जिनमें विशेष AL / AX / EAX वाले हैं, जिनमें कोई modr / m नहीं है, बस op + imm8 / 16/32 है। इस उत्तर के उदाहरण हैं
पीटर कॉर्ड्स

1

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

+23;[ans,i]((N==ans)+1)

यदि एन = एल * एम, तो अभिव्यक्ति वापस आ जाती है 0+i(अर्थात विशुद्ध रूप से काल्पनिक संख्या), अन्यथा अभिव्यक्ति एक वास्तविक घटक के साथ एक जटिल संख्या में परिणाम देती है।

एक अतिरिक्त बाइट की कीमत पर थोड़ा अच्छे परिणाम के लिए:

+24;[ans,-1]((N==ans)+1)

यदि एन = एल * एम अभिव्यक्ति वापस आती है -1, अन्यथा एक सकारात्मक संख्या।

डेमो:

N=48;
+24;[ans,-1]((N==ans)+1)                                                 #>> 24 
+24;[ans,-1]((N==ans)+1)+24;[ans,-1]((N==ans)+1)                         #>> -1
+24;[ans,-1]((N==ans)+1)+24;[ans,-1]((N==ans)+1)+24;[ans,-1]((N==ans)+1) #>> 23

पुनश्च, आप एक ही परिणाम प्राप्त कर सकते हैं, +24;if N==ans;-1;end;ansलेकिन बायटेकाउंट समान है


1

लुआ, 56 46 बाइट्स

a=(a or io.read())-46io.write(a<=0 and a or"")

एक 0 (एक अनुगामी न्यूलाइन के बिना) यदि समान और कुछ भी नहीं या नकारात्मक संख्याओं की एक श्रृंखला (कुछ मामलों में पूर्ववर्ती शून्य के साथ) यदि नहीं के बराबर है।

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

बार-बार एक गुच्छा: इसे ऑनलाइन आज़माएं!

व्याख्या

a=(a or io.read())-46

पहले पुनरावृत्ति पर (जब aअभी तक परिभाषित नहीं किया गया है और इसलिए nil), aइनपुट से लिए गए एक नंबर पर सेट होता है, अन्यथा स्वयं के लिए। दोनों मामलों में, 46 तब से घटाया जाता है a

io.write(a<=0 and a or"")

यह सिर्फ प्रिंट करता है aअगर यह उन मामलों से कम है (उन मामलों की देखभाल के लिए जहां इनपुट कुल लंबाई से बड़ा था) या शून्य के बराबर, और खाली स्ट्रिंग अन्यथा।

-१० बाइट्स यह याद रखने के लिए कि लूआ संख्या और तारों के बीच स्वतः रूपांतरण करता है। ओह।


0

जावास्क्रिप्ट (ईएस 6), 47 बाइट्स

यह इस उत्तर में बेनोइट एसनार्ड के समान तकनीक का उपयोग कर रहा है ( मैं स्रोत को दोगुना करता हूं, आप आउटपुट को दोगुना करते हैं! )।

प्रिंटों 0 अगर n = 47 * M , या एक गैर-शून्य मान अन्यथा।

n=prompt(setTimeout`alert(n)`)-47/*
n-=47//*///

M = 1 के लिए डेमो

n=prompt(setTimeout`alert(n)`)-47/*
n-=47//*///

एम = 2 के लिए डेमो

n=prompt(setTimeout`alert(n)`)-47/*
n-=47//*///n=prompt(setTimeout`alert(n)`)-47/*
n-=47//*///


0

ब्रेन-फ्लैक , 24 बाइट्स

({}[(((()()()){}){}){}])

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

बस इनपुट से 24 घटाते हैं। आउटपुट0सत्य के लिए और असत्य के लिए कुछ भी।

ब्रेन-फ्लैक , 68 बाइट्स

{<>}<>(({}[((((()()()()){}){}()){}){}])<>{})((){[()](<{}<>>)}{}<>{})

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

यह एक अधिक परिष्कृत है यह 1सच है और 0झूठे के लिए आउटपुट है ।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.