* के लिए एक दुभाषिया लिखें

20

कार्य सरल है। भाषा के लिए एक दुभाषिया लिखें * ।

यहां विकी का एक बड़ा लिंक है।

केवल तीन मान्य * कार्यक्रम हैं:

  • * प्रिंट "हैलो वर्ल्ड"
  •  *  0 और 2,147,483,647 के बीच एक यादृच्छिक संख्या प्रिंट करता है
  • *+* हमेशा के लिए भागता है।

तीसरा प्रश्न इस प्रश्न में विशिष्टताओं के अनुसार एक अनंत लूप होना चाहिए

इनपुट:

  • इनपुट को हमारे मानक I / O नियमों द्वारा किसी भी स्वीकार्य इनपुट विधि के माध्यम से लिया जा सकता है
  • यह हमेशा उपरोक्त कार्यक्रमों में से एक होगा

आउटपुट:

  • पहले मामले को Hello Worldएक अनुगामी रेखा के विराम के साथ या उसके बिना बिल्कुल प्रिंट करना चाहिए ।
  • दूसरे मामले के लिए, यदि आपकी भाषा का पूर्णांक अधिकतम 2,147,483,647 से छोटा है, तो अपनी भाषा के पूर्णांक का उपयोग करें
  • पहले और दूसरे मामले हमारे मानक I / O नियमों द्वारा किसी भी स्वीकार्य आउटपुट पर प्रिंट कर सकते हैं।
  • तीसरे मामले में कोई आउटपुट नहीं देना चाहिए।

स्कोरिंग:

चूंकि यह कोड-गोल्फ है , बाइट्स में सबसे छोटा जवाब, जीत।

code-golf  interpreter  code-golf  array-manipulation  sorting  code-golf  halting-problem  code-golf  javascript  code-golf  algorithm  code-golf  arithmetic  code-golf  math  counting  code-golf  math  code-golf  decision-problem  radiation-hardening  code-golf  conversion  bitwise  code-golf  number  decision-problem  code-golf  string  decision-problem  code-golf  random  game  code-golf  ascii-art  graphical-output  code-golf  decision-problem  binary-tree  tree-traversal  code-challenge  array-manipulation  code-challenge  graphical-output  path-finding  test-battery  algorithm  code-golf  integer  factorial  code-golf  binary-tree  code-golf  grid  graph-theory  code-golf  regular-expression  quine  code-golf  encoding  code-golf  king-of-the-hill  javascript 
— TheOnlyMrCat
स्रोत
7
जब आप 'बीच 0और 2,147,483,647' कहते हैं , तो क्या यह समावेशी या अनन्य है? (जैसे, 0एक वैध आउटपुट है?)
— चास ब्राउन
7
चुनौती पोस्ट करने और मौजूदा समाधानों को अमान्य करने के बाद कल्पना को बदलना -1मेरे लिए एक स्वचालित है।
— झबरा
2
ऐसी भाषाओं के लिए जिनमें यादृच्छिक संख्या उत्पन्न करने का कोई अंतर्निहित तरीका नहीं है, क्या "प्रिंट करने के लिए एक यादृच्छिक संख्या" आवश्यकता को पूरा करने का एक स्वीकार्य तरीका है?
— टेनर स्वेट
2
यदि हमारी भाषा के पूर्णांक में कोई या अधिक नहीं है, तो अधिकतम क्या हम एक उच्च ऊपरी सीमा का उपयोग कर सकते हैं?
— जोनाथन एलन
7
@ शिग्गी मैं प्रश्न के लिए विकी में कोई नियम परिवर्तन नहीं देख रहा हूं, केवल एक गैर-ब्रेकिंग स्पेस के लिए एक स्थान (मार्कडाउन टैब की जांच करें), क्योंकि एसई मार्कडाउन रेंडरर इसे प्रतिपादन नहीं कर रहा था, लेकिन मूल संशोधन को देख रहा था , यह स्पष्ट है कि यह सामान्य रिक्त स्थान होना चाहिए, और "हैक 'केवल एसई
— मार्कडाउन

जवाबों:

20

* , 0 बाइट्स

चूंकि * में इनपुट पढ़ने का कोई तरीका नहीं है, इसलिए डिफ़ॉल्ट नियम यह निर्दिष्ट करने की अनुमति देते हैं कि इनपुट को प्रोग्राम पर इसे संक्षिप्त करके दिया जाना चाहिए ।

(... मुझे लगता है कि "डाउनवोट्स के रूप में कम से कम दो बार" स्थिति है कि मुझे सत्यापित करने के लिए प्रतिनिधि नहीं है)।

— हेनिंग मखोलम
स्रोत
4
आपका लिंक किया गया मेटा वास्तव में वर्तमान में स्वीकृत साइट मानक (+31 -7) है।
— जोनाथन एलन
2
@A__: यह मुझे ऐसा लगता है कि इसे विशेष रूप से 'प्रोग्रामिंग लैंग्वेज' की प्रस्तावित परिभाषा को संतुष्ट करने के लिए तैयार किया गया होगा ("आप हैलो वर्ल्ड लिख सकते हैं!" "आप एक अनंत लूप लिख सकते हैं!" "आप एक प्रोग्राम लिख सकते हैं जो करता है 't हमेशा एक ही काम करते हैं! ")।
— हेनिंग मैखोलम
मेरा मानना ​​है कि तकनीकी रूप से Malbolge एक प्रोग्रामिंग भाषा नहीं है।
— बॉब जेनसेन
1
Malbolge परिमित ऑटोमेटा के लिए प्रोग्रामिंग भाषा है, * के समान, और, उदाहरण के लिए, Befunge-93। इसलिए Malbolge औपचारिक प्रोग्रामिंग भाषा है, * के रूप में ही, तकनीकी रूप से पुनरावर्ती भाषाओं के समान ही है जब प्रोग्रामिंग भाषा की परिभाषा आती है (यद्यपि औपचारिक भाषाएं कम शक्तिशाली होती हैं)।
— Krzysztof Szewczyk
मेरे द्वारा डाउनवोट करें, क्योंकि ईमानदारी से, यह उत्तर बहुत उबाऊ है, यह वास्तव में पहले से ही एक मानक लूपहोल है , भले ही हम इस प्रश्न को अनदेखा कर दें कि क्या * एक प्रोग्रामिंग भाषा है
— एलियनएटसिस्टम
8

आर , 69 बाइट्स

switch(scan(,""),"*"="Hello, World!"," * "=sample(2^31,1)-1,repeat{})

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

switchनामित तर्कों का मिलान करने की कोशिश करता है और अगर कोई मेल नहीं है, तो पहले के बाद पहला अनाम चुनें, जो इस मामले में सबसे अनन्त लूप है repeat{}।

— ग्यूसेप
स्रोत
6

जेली ,  21  20 बाइट्स

ḊOSØ%HX’¤“½,⁾ẇṭ»¹Ḃ¿?

पात्रों की सूची को स्वीकार करने वाला एक अद्वैत लिंक।

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

vL’... यह भी काम करता है (नीचे देखें)।

कैसे?

ḊOSØ%HX’¤“½,⁾ẇṭ»¹Ḃ¿? - Link: list of characters   e.g.: "*"        or  " * "    or  "*+*"
Ḋ                    - dequeue                          ""             "* "         "+*"
 O                   - to ordinals                      []             [42,32]      [43,42]
  S                  - sum                              0              74           85
                   ? - if...
                  ¿  - ...if-condition: while...
                 Ḃ   -    ...while-condition: modulo 2  0              0            1
                ¹    -    ...while-true-do: identity                                85
                     -                                  0              74           (looping)
        ¤            - ...then: nilad followed by link(s) as a nilad:
   Ø%                -    literal 2^32                                 2^32
     H               -    half                                         2^31
      X              -    random integer in [1,n]                      RND[1,2^31]
       ’             -    decrement                                    RND[0,2^31)
         “½,⁾ẇṭ»     - ...else: dictionary words        "Hello World"

विकल्प

vL’... - Link: list of characters                 e.g.: "*"        or  " * "    or  "*+*"
 L     - length                                         1              3            3
v      - evaluate (left) as Jelly code with input (right)
       -                                                1^1            3^3          (3^3+3)^3
       -                                                1              27           27000
  ’    - decrement                                      0              26           26999
   ... - continue as above                              "Hello World"  RND[0,2^31)  (looping)
— जोनाथन एलन
स्रोत
5

सी (जीसीसी) , 66 63 बाइट्स

-3 बाइट्स के लिए उपस्थित होने के लिए धन्यवाद।

मुझे केवल दूसरे चरित्र की जांच करनी है: यदि एलएसबी सेट है, तो यह एक है +(इस प्रकार कार्यक्रम " *+*" है) और प्रोग्राम लूप करता है। उसके बाद, यदि यह एक है NUL, तो कार्यक्रम " *" था और हम प्रदर्शित करते हैं Hello World; अन्यथा, यह एक यादृच्छिक मान प्रदर्शित करता है ("  * ", केवल दूसरा विकल्प बचा है।)

f(char*s){for(s++;*s&1;);printf(*s?"%d":"Hello World",rand());}

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

— ErikF
स्रोत
— एटीनैट
बाइट शेव करें:f(char*s){*++s&1?f(s-1):printf(*s?"%d":"Hello World",rand());}
— रोमन ओडिसी
पेडिटिक नोट: randपर्याप्त रूप से बड़े मूल्य को वापस करने की गारंटी नहीं है; RAND_MAXऔर INT_MAXएक ही होने की गारंटी नहीं कर रहे हैं (और वास्तविक दुनिया compilers पर नहीं हैं, जैसे दृश्य स्टूडियो के RAND_MAXहै 32767, जबकि INT_MAXहै [आधुनिक x86 पर ली गई प्रणाली] 2147483647मूल्य ओपी के सवाल में निर्दिष्ट)।
— शैडो रेंजर
@ShadowRanger जो पूरी तरह से सच है, लेकिन यह देखते हुए कि> सभी C- आधारित CGCC प्रविष्टियों में से 90% अपरिभाषित और अनिर्दिष्ट व्यवहार पर निर्भर हैं, मैं उस बारे में चिंतित नहीं हूँ! मुझे आज कोड-गोल्फ एलसीजी लागू करने का भी मन नहीं था। :-)
— एरिकएफ
5

पायथन 2 , 103 93 89 87 बाइट्स

मैंने चास ब्राउन्स के उत्तर के साथ अपने पहले के उत्तर को मिला दिया और कुछ बाइट्स को छोटा कर लिया।

यादृच्छिक संख्या 0 और 2 ** 31-1 के बीच होगी।

from random import*
i=input()
while'*'<i:1
print["Hello World",randrange(2**31)][i<'!']

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

पिछला संस्करण:

103 बाइट्स

from random import*
exec['print"Hello World"','while 1:1','print randint(0,2**31-1)'][cmp(input(),'*')]

93 बाइट्स

from random import*
i=cmp(input(),'*')
while i>0:1
print["Hello World",randint(0,2**31-1)][i]
— mbomb007
स्रोत
के randint(0,2**31-1)साथ प्रतिस्थापित करके 2 बाइट्स सहेजें randrange(2**31)।
— चास ब्राउन
while'*'<i2 बचाता है
— जोनाथन एलन
बदलकर एक और बाइट सहेजें randrange(2**31)करने के लिए getrandbits(31)(बाद रिटर्न long, नहीं intहै, लेकिन printप्रिंट होगा strफार्म, नहीं reprप्रपत्र, तो पीछे Lनहीं होगी)।
— शैडो रेंजर
साइट के साथ अपेक्षाकृत अनुभवहीन, इतनी जल्दी स्पष्टीकरण: क्या आपको अपने इनपुट को उद्धृत करने की आवश्यकता है? i=input()अगर इनपुट सिर्फ उद्धृत किया जाता है तो केवल काम करता है, यदि आप सिर्फ इनपुट सादे करते हैं */ * /*+*, तो यह एक के साथ मर जाएगा SyntaxError(क्योंकि inputइसमें निहित है eval); आपको इनपुट करने की आवश्यकता होगी '*'/' * '/'*+*'(या इसके बजाय डबल-कोट्स के बराबर)। मुझे मानक I / O नियमों पर कुछ भी स्पष्ट नहीं दिखाई दिया , जो इसे अनुमति देगा, जिसका अर्थ हो सकता है कि आपको raw_input()चार बाइट की लागत का उपयोग करने की आवश्यकता होगी ।
— शैडो रेंजर
@ShadowRanger input()इनपुट के रूप में एक स्ट्रिंग लेता है और इसका मूल्यांकन करता है। मैं वास्तव में इनपुट में शामिल नहीं हूं, मैं केवल एक स्ट्रिंग को इनपुट के रूप में ले रहा हूं, और स्ट्रिंग में उद्धरण हैं। यह सुंदर मानक है, उसी तरह कि मैं [1,2,3]एक सीमांकित स्ट्रिंग के बजाय एक सरणी ले सकता हूं जिसे मुझे फिर विभाजित और पार्स करना होगा। साइट का लक्ष्य इनपुट को सख्त बनाना नहीं है, यह I / O को आसान बनाना है ताकि हम कोड को चुनौती पर ध्यान केंद्रित कर सकें।
— mbomb007
5

केग , -lp, -ir 30 26 25 24 20 19 बाइट्स

!1=[_“H%c¡“| =[~.|{

झंडे का उपयोग करते हुए -1 बाइट

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

उत्तर इतिहास

?!1=[_“H%c¡“| =[~.|{

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

Hello Worldशब्दकोश स्ट्रिंग को छोटा किया

!1=[_Hello World| =[~.|{

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

मैं केजी की शक्ति पर चकित होना कभी नहीं छोड़ा। सहेजे गए एक और बाइट के लिए उपयोगकर्ता EdgyNerd को क्रेडिट।

पूर्व संस्करण

_!0=[Hello World|\*=[~.|{

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

सहेजे गए अतिरिक्त बाइट के लिए उपयोगकर्ता A__ को श्रेय।

पुराना संस्करण

?!1=[_Hello World| =[__~|{

अनिवार्य रूप से, इनपुट प्रोग्राम और:

  • यह देखने के लिए जाँच करता है कि क्या इनपुट लंबाई 1 है, "हैलो वर्ल्ड" को प्रिंट करना यदि सही है
  • यह देखने के लिए जांचता है कि क्या अंतिम वर्ण एक स्थान है, और एक यादृच्छिक संख्या प्रिंट करता है
  • अन्यथा एक अनंत लूप चलाता है

फिर स्टैक को स्पष्ट रूप से प्रिंट करें।

?                               #Get input from the user
 !1=                            #Compare the stack's length to 1
    [_Hello World           #Push "Hello, World!" to the stack
                     | =        #See if top item is a space
                        [__~|{  #If so, generate a random number, otherwise, infinite loop.

इस तथ्य के कारण 4 बाइट्स बचाए गए हैं कि हैलो वर्ल्ड के लिए विराम चिह्न की आवश्यकता नहीं है।

इसे ऑनलाइन आज़माएं! पुराना संस्करण

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

— जोनो 2906
स्रोत
आप 4 बाइट्स काट सकते हैं, आपको "हैलो वर्ल्ड" में अल्पविराम या विस्मयादिबोधक चिह्न की आवश्यकता नहीं है।
— TheOnlyMrCat
1
अब मुझे सामान्य रूप से चुनौतियों का जवाब देने के लिए एक और अलोकप्रिय भाषा सीखनी होगी।
— एक
1
-1 बाइट्स: टीआईओ । मुझे खुशी है कि मैंने केग में गोल्फ के लिए अपनी क्षमता नहीं खोई।
— एक
@A__ TIO पर कीग का आनंद ले रहे हैं?
— जोनो 2906
2
— EdgyNerd
3

Befunge-93 , 54 बाइट्स

~"*"-_~1+#^_"dlroW olleH">:#,_@.%*2**:*::*88:*`0:?1#+<

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

एनोटेट:

~"*"-                      _                ~1+                   #^_        "dlroW olleH">:#,_    @      .%*2**:*::*88:   *`0:             ?1#+<
Compare first      If equal, go right       Compare second       If equal,        Output          Exit    Modulo by 2^31   If less than      Add 1
character to       Otherwise, go left       character to       loop forever   "Hello World"                 and output     0, multiply     a random amount
'*'                and wrap around          -1 (EOF)                                                                         by 0            of times

यादृच्छिकता एक समान नहीं है। प्रत्येक वेतन वृद्धि पर वेतन वृद्धि रोकने का 50% मौका है।

— नकारात्मक सात
स्रोत
3

जाप , 22/25 बाइट्स

पहला समाधान मूल कल्पना के लिए है, जो *<space>दूसरे कार्यक्रम के रूप में था और दूसरा अद्यतन किए गए कल्पना के लिए है <space>*</space>, जिसने मनमाने ढंग से इसे बदल दिया, सुझाव "फिक्स" के लिए ईओआई के लिए धन्यवाद।

दोनों तीसरे कार्यक्रम के अनंत लूप में प्रवेश करने पर एक अतिप्रवाह त्रुटि फेंकते हैं लेकिन, सैद्धांतिक रूप से, पर्याप्त मेमोरी (जिसे हम कोड-गोल्फ के प्रयोजनों के लिए मान सकते हैं ) के साथ, हमेशा के लिए चलेगा।

Å?¢?ß:2pHÉ ö:`HÁM Wld

प्रोग्राम 1
आज़माएँ प्रोग्राम 2
आज़माएँ प्रोग्राम 3 आज़माएँ

Å?UÎ>S?ß:2pHÉ ö:`HÁM Wld

प्रोग्राम 1
आज़माएँ प्रोग्राम 2
आज़माएँ प्रोग्राम 3 आज़माएँ

— झबरा
स्रोत
मुझे लगता है कि दूसरा कार्यक्रम "[SPACE] * [SPACE]" है, न कि "[SPACE] *", इसलिए आपका प्रोग्राम काम नहीं करता
— इग्नोरेंस
@EmbodimentofIgnorance, जिस समय मैंने पोस्ट किया, कल्पना में दूसरा कार्यक्रम था *<space> । अब अपडेट करने का समय नहीं है।
— झबरा
आप इसे दूसरी बर्नरी के UÌ>Sबजाय तीन बाइट्स में ठीक कर सकते हैं¢
— अज्ञानता का अवतार
@Downvoter, कृपया टिप्पणी छोड़ने के लिए शिष्टाचार रखें।
— झबरा
2

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

s=>s[1]?s<'!'?Math.random()*2**31|0:eval(`for(;;);`):'Hello World'

इसे ऑनलाइन आज़माएं! (नमस्ते दुनिया)

इसे ऑनलाइन आज़माएं! (यादृच्छिक संख्या)

इसे ऑनलाइन आज़माएं! (अनंत लूप)

— Arnauld
स्रोत
x=(z=>x())&&x()अनंत लूप कोड से -1byte के लिए काम नहीं करेगा , जिसमें कोई अधिकतम कॉल स्टैक आकार वाला ब्राउज़र है?
— गीज़ा केर्केसेनी
@GezaKerecsenyi हम सिर्फ अपने आप को ( इस तरह ) कह सकते हैं , लेकिन मुझे यकीन नहीं है कि यह स्वीकार्य होगा।
— अरनुलद
ये उचित है। मुझे आश्चर्य है कि अगर वहाँ कुछ अस्पष्ट ब्राउज़र है जो बस चलता रहता है (कम से कम, जब तक रैम बाहर नहीं निकलता है)
— गीज़ा केरेसेनी
1
@Arnauld, सैद्धांतिक रूप से, वह हमेशा के लिए दी गई अनंत स्मृति को चलाएगा, जिसे हम कोड गोल्फ के लिए मान सकते हैं।
— झबरा
2

जेली , 23 21 बाइट्स

OS¹Ḃ¿ịØ%HX’;““½,⁾ẇṭ»¤

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

एक एकल लिंक एक तर्क ले रहा है और वापस लौट रहा है Hello World, एक यादृच्छिक 31 बिट पूर्णांक या लूप असीम रूप से कल्पना के अनुसार।

सभी विकल्प: * * *+*

व्याख्या

O                     | Convert to codepoints
 S                    | Sum
  ¹Ḃ¿                 | Loop the identity function while odd 
     ị              ¤ | Index into the following as a nilad:
      Ø%              | - 2 ** 32
        H             | - Halved
         X            | - Random integer in the range 1..2**31
          ’           | - Decrease by 1 
           ;          | - Concatenated to:
            ““½,⁾ẇṭ»  |   - "", "Hello World"
— निक केनेडी
स्रोत
2

पायथन 2 , 91 89 88 बाइट्स

from random import*
def f(p):
 while'*'<p:p
 print['Hello World',getrandbits(31)][p<'!']

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

जोनाथन एलन को 2 बाइट्स धन्यवाद ; शैडो रेंजर को 1 बाइट ।

— चास ब्राउन
स्रोत
while'*'<p2 बचाता है
— जोनाथन एलन
getrandbits(31)एक बाइट बचाता है randrange(2**31)।
— शैडो रेंजर
अच्छा! Getrandbits के बारे में नहीं पता था ...
— चास ब्राउन
2

पॉवरशेल, 60 , 56 बाइट्स

switch($args){*{'Hello World'}' * '{random}*+*{for(){}}}

सुंदर गूंगा संस्करण, यहाँ एकमात्र गोल्फ तकनीक में चूक Get-है Get-Random।

युपीडी। उद्धरणों को हटाकर 56 बाइट्स तक नीचे गिराया गया, veskah के लिए धन्यवाद !

— beatcracker
स्रोत
1
56
— स्ट्रिप्स
1

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

Ｗ№θ*Ｆ⁼θ*≔Hello Worldθ∨θＩ‽Ｘ²¦³¹

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। चारकोल के डिफ़ॉल्ट इनपुट प्रारूप का दुरुपयोग करता है जो केवल एक लाइन होने पर रिक्त स्थान पर विभाजित होता है, इस प्रकार यादृच्छिक संख्या इनपुट वास्तव में तीन इनपुट की तरह दिखता है। स्पष्टीकरण:

Ｗ№θ*

पहला इनपुट होते समय दोहराएं *।

Ｆ⁼θ*

यदि पहला इनपुट *केवल ...

≔Hello Worldθ

... तो इसे प्रतिस्थापित करें Hello World, इस प्रकार लूप को समाप्त किया जाएगा। *+*प्रतिस्थापित नहीं होता है, जिसके परिणामस्वरूप एक अनंत लूप होता है।

∨θ

यदि पहला इनपुट खाली नहीं है तो इसे आउटपुट करें।

Ｉ‽Ｘ²¦³¹

लेकिन अगर यह खाली है तो वांछित रेंज में एक यादृच्छिक पूर्णांक आउटपुट करें।

— नील
स्रोत
1

++ , 78 बाइट्स जोड़ें

z:"Hello World"
`y
xR2147483647
x:?
a:"*"
b:" * "
c:"*+*"
Ix=a,Oz
Ix=b,O
Wx=c,

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

व्याख्या

z:"Hello World"	; Set z = "Hello World"
`y		; Set y as the active variable
xR2147483647	; Set y to a random number between 0 and 2147483647
x:?		; Set x to the input
a:"*"		; Set a = "*"
b:" * "		; Set b = " * "
c:"*+*"		; Set c = "*+*"
Ix=a,		; If x == a then...
	Oz	;	...output z
Ix=b,		; If x == b then...
	O	;	...output y
Wx=c,		; While x == c then...
		;	...do nothing
— केर्ड सिक्काहिरिंग
स्रोत
1

ब्रेकीलॉग , 26 23 बाइट्स

l₃∈&hṢ∧2^₃₁-₁ṙw∨Ḥ⊇ᶠ³⁶tw

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

कार्यक्रम को इनपुट चर के माध्यम से एक स्ट्रिंग के रूप में लेता है, और आउटपुट चर को अनदेखा करता है। भारी गारंटी देता है कि इनपुट केवल तीन वैध कार्यक्रमों में से एक है: कोई भी लंबाई-तीन इनपुट " * "या तो व्यवहार करेगा या "*+*"इस पर निर्भर करेगा कि पहला चरित्र एक स्थान है या नहीं, और कोई भी अन्य इनपुट जैसा व्यवहार करेगा "*"।

l₃                         The input has length 3
  ∈                        and is an element of something,
   &h                      and the input's first element
     Ṣ                     is a space
  ∈                        (if not, try some other thing it's an element of),
      ∧2^₃₁-₁              so take 2,147,483,647 and
             ṙw            print a random number between 0 and it inclusive.
               ∨           If the input's length isn't 3,
                Ḥ⊇ᶠ³⁶tw    print the 36th subsequence of "Hello, World!".
— असंबंधित स्ट्रिंग
स्रोत
उफ़, गलत "हैलो वर्ल्ड" - अब फिक्सिंग
— असंबंधित स्ट्रिंग
1

PHP , 51 बाइट्स

for(;'*'<$l=$argn[1];);echo$l?rand():'Hello World';

इसे ऑनलाइन आज़माएं! (नमस्ते दुनिया)

इसे ऑनलाइन आज़माएं! (यादृच्छिक संख्या)

इसे ऑनलाइन आज़माएं! (अनंत लूप)

इनपुट का दूसरा चरित्र लेता है '', जो हो सकता है , '*'या '+'। के मामले में किसी और सच हो जाएगा और पाश अनंत हो जाएगा,, पाश के बाद, "नमस्ते विश्व" या एक यादृच्छिक संख्या दिखाया गया है। स्वचालित रूप से 0 और बीच की एक संख्या आउटपुट जो का उपयोग करता है परिभाषित मानक सी पुस्तकालय में और डिफ़ॉल्ट रूप से है सबसे प्लेटफार्मों / वातावरण, TIO सहित पर।'+''*'<'+'rand()getrandmax()RAND_MAX2147483647

— Night2
स्रोत
1

05AB1E , 21 बाइट्स

'*KgDi[ë<ižIL<Ω딟™‚ï

इसे ऑनलाइन आज़माएं। (नोट: यादृच्छिक बिल्डिन बड़ी सूचियों के साथ बहुत धीमा है, इसलिए परिणाम आने से पहले कुछ समय लग सकता है।)

स्पष्टीकरण:

'*K           '# Remove all "*" from the (implicit) input
   g           # Get the length of what's remain (either 0, 1, or 2)
    D          # Duplicate this length
     i         # If the length is exactly 1:
      [        #  Start an infinite loop
     ë<i       # Else-if the length is 2:
        žI     #  Push builtin 2147483648
          L    #  Create a list in the range [1,2147483648]
           <   #  Decrease each by 1 to make the range [0,2147483647]
            Ω  #  Pop and push a random value from the list
               #  (after which the top of the stack is output implicitly as result)
     ë         # Else:
      ”Ÿ™‚ï    #  Push dictionary string "Hello World"
               #  (after which the top of the stack is output implicitly as result)

मेरा यह 05AB1E टिप देखें (अनुभाग कैसे शब्दकोश उपयोग कैसे करें? ) को समझने के लिए क्यों ”Ÿ™‚ïहै "Hello World"।

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

पायथ , 32 बाइट्स

It/Jw\*#;?tlJOhC*4\ÿ"Hello World

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

स्पष्टीकरण (पायथन-ईश)

I                                   # if 
  /Jw\*                             #    (J:=input()).count("*"))
 t                                  #                             - 1:
       #;                           #     try: while True: pass;except: break;
         ?                          # if (ternary)
           lJ                       #    len(J):
             O                      #     randInt(0,                    )
               C                    #                int(     , 256)
                *4\ÿ                #                    4*"ÿ"
              h                     #                                + 1
                    "Hello World    # else: (implicitly) print "Hello World"
— ar4093
स्रोत
यह 0 और 2 ^ 32 के बीच एक नंबर प्रिंट करता है, 0 और 2 ^ 31 नहीं। लिखने hC*4\ÿका एक छोटा तरीका है ^2 32, लेकिन समाधान सही होने के लिए, आपको ^2 31इसके बजाय उपयोग करना चाहिए । इसके अलावा, के zबजाय का उपयोग करें Jw, 1 और बाइट बचाता है। और आपका स्पष्टीकरण tठीक पहले वाली रेखा को छोड़ देता है lJ।
— randomdude999
इसके अलावा, आप "लूप फॉरएवर" कमांड का पता लगाकर यह जांच सकते हैं कि इनपुट में कोई +वर्ण है या नहीं, 1 बाइट बचाता है क्योंकि आपको इसे कम करने की आवश्यकता नहीं है।
— randomdude999
0

एपीएल (Dyalog यूनिकोड) , 39 बाइट्स SBCS

अनाम उपसर्ग लंबोदर।

{'+'∊⍵:∇⍵⋄' '∊⍵:⌊2E31×?0⋄'Hello World'}

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

{ "DFN"; ⍵तर्क है:

 '+'∊⍵: यदि प्लस तर्क का सदस्य है:

  ∇⍵ पूंछ तर्क पर पुनर्विचार

 ' '∊⍵ यदि अंतरिक्ष तर्क का सदस्य है:

  ?0 यादृच्छिक फ्लोट (0-1)

  2E31× स्केल (0-2³¹)

  ⌊ मंज़िल

 'Hello World' स्ट्रिंग वापस करें

— एडम
स्रोत
0

कमोडोर BASIC (VIC-20, C64, TheC64Mini आदि) - 170 टोकन बेसिक बाइट्स

 0a%=32767:goS9:b$=leF(b$,len(b$)-1):ifb$="*"tH?"hello world
 1ifb$=" * "tH?int(rN(ti)*a%)
 2ifb$="*+*"tHfOi=.to1:i=.:nE
 3end
 9b$="":fOi=.to1:geta$:i=-(a$=cH(13)):b$=b$+a$:?a$;:nE:reT

मुझे लगता है कि इसे और अधिक सटीक रूप से करना है, मुझे 6502 असेंबली भाषा की अजीब दुनिया में जाना होगा, लेकिन यह पहला मसौदा है।

पहला बिंदु, INPUTकमोडोर बेसिक में कीवर्ड सफेद रिक्त स्थान को अनदेखा करता है, इसलिए लाइन पर उप-रूटीन 9रिक्त स्थान सहित कीबोर्ड प्रविष्टियों को स्वीकार करने का एक त्वरित और गंदा तरीका है।

दूसरा बिंदु, कमोडोर बेसिक पूर्णांक में 16-बिट पर हस्ताक्षर किए जाने की एक सीमा है, इसलिए -32768 से +32767 स्रोत तक - इसलिए मैंने 0 से उत्पन्न यादृच्छिक संख्या को रखा है - 32767 समावेशी

— शॉन बीबर
स्रोत
0

व्रन ,143 135 बाइट्स

मैं एक अच्छा गोल्फर नहीं हूं ... आरएनजी हर बार एक ही मूल्य उत्पन्न करता है क्योंकि यह एक छद्म यादृच्छिक संख्या जनरेटर है।

Fn.new{|a|
import"random"for Random
if(a=="*+*"){
while(1){}
}else System.write(a[0]==" "?Random.new(9).int((1<<31)-1):"Hello World")
}

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

— ए
स्रोत
0

जावास्क्रिप्ट, 63 बाइट्स, कोई अनंत पुनरावर्ती नहीं

s=>s[1]?Math.random()*2**31|eval("while(s>'!');"):'Hello World'

बुरा नेटवर्क तो कोई TIO लिंक

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