19

एक प्रोग्राम बनाएं, जो एक हैलो वर्ल्ड स्ट्रिंग ("हैलो वर्ल्ड", "हैलो, वर्ल्ड" आदि) और सोर्स कोड को आउटपुट करता है। आउटपुट को stdout या समकक्ष लिखा जाता है। हैलो वर्ल्ड स्ट्रिंग को सोर्स कोड में एम्बेड किया गया है।

उदाहरण के लिए, आउटपुट हो सकता है

(some source code here)hello world(some source code here)

जब आउटपुट फिर से संकलित या व्याख्या किया जाता है, तो उसे एक समान आउटपुट बनाना चाहिए, लेकिन हैलो वर्ल्ड स्ट्रिंग में एक अलग विराम चिह्न या कैपिटलाइज़ेशन होना चाहिए। उदाहरण के लिए, पिछला उदाहरण निम्नलिखित आउटपुट बना सकता है

(some source code here)hello, wORld(some source code here)

इन उदाहरणों में प्रत्येक "(कुछ स्रोत कोड)" प्रत्येक निष्पादन के बाद बदल सकता है, या यह समान हो सकता है।

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

निम्नलिखित विराम चिह्न मान्य है:

hello, world
hello world
helloworld

कोई भी पूंजीकरण स्वीकार्य है। उदाहरण के लिए, ये मान्य हैलो वर्ल्ड स्ट्रिंग्स हैं:

Hello, world
hellO WORld
HELLoworlD

ये तार मान्य नहीं हैं:

Hello     world
Hello(newline)world
Hello,world
Hello, Steve

जैसे ही निम्न में से एक शर्तें पूरी होती हैं, आपका कार्यक्रम विफल हो जाता है:

यह एक हैलो वर्ल्ड स्ट्रिंग को आउटपुट करता है जो कुछ पुराने निष्पादन के दौरान आउटपुट किया गया है,
आउटपुट अब उसी भाषा में मान्य स्रोत कोड नहीं है, या
आउटपुट में ठीक एक मान्य हैलो वर्ल्ड स्ट्रिंग नहीं है।

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

प्रारंभिक कार्यक्रम के स्रोत कोड में बाइट्स की मात्रा के रूप में गणना की जाती है। सबसे कम स्कोर जीतता है।

निम्नलिखित बोनस लागू होते हैं (-60% तक):

-5% * (एन - 2), जहां एन निष्पादन का सूचकांक है जिसके बाद आपका प्रोग्राम अमान्य आउटपुट का उत्पादन करता है। यह बोनस -50% पर कैप करता है। यदि आपका प्रोग्राम 12 बार या उससे अधिक सफल होता है, तो आपको अधिकतम बोनस मिलता है।
-10%, अगर आपके आउटपुट (पहले स्रोत कोड सहित) में तीनों मान्य विराम चिह्न विकल्प शामिल हैं।

आपके प्रस्तुतिकरण में पहला स्रोत कोड शामिल होना चाहिए, और इसमें सफल निष्पादन के आउटपुट भी होने चाहिए। यदि आपका प्रोग्राम 12 से अधिक बार सफल होता है, तो 12 निष्पादन के लिए आउटपुट जोड़ें।

उदाहरण

अगली पंक्ति पहला स्रोत कोड है। जब हम इसे निष्पादित करते हैं, तो यह पहला निष्पादन है।

hello world(some source code here)

अगली पंक्ति पहले स्रोत कोड कोड से आउटपुट है। यह पहला आउटपुट है।

hello, world(some source code here)

अगली पंक्ति दूसरी निष्पादन से आउटपुट है। यह दूसरा आउटपुट है।

helloworld(some source code here)

जब हमने पहला आउटपुट निष्पादित किया, तो यह प्रोग्राम -10% बोनस के लिए योग्य हो गया। इसका मतलब है कि हमारे पास दो आउटपुट हैं, और एक मूल कोड है, जिसमें सभी के अलग-अलग विराम चिह्न हैं। इसके अलावा, क्योंकि दूसरा आउटपुट वैध था, यह कार्यक्रम इस प्रतियोगिता के लिए योग्य है।

अगली पंक्ति तीसरी निष्पादन से आउटपुट है। यह तीसरा आउटपुट है।

Helloworld(some source code here)

अगली पंक्ति चौथे निष्पादन से आउटपुट है। यह चौथा आउटपुट है।

hellworld(some source code here)

यह आउटपुट अमान्य था। अंतिम वैध निष्पादन का सूचकांक था 4. यह कार्यक्रम विराम चिह्न से -5% * (4 - 2) बोनस और -10% बोनस के लिए पात्र है। यह कुल -20% बनाता है। पहले स्रोत कोड की लंबाई ("हैलो वर्ल्ड (यहां कुछ स्रोत कोड)") 34 बाइट्स थी, इसलिए अंतिम स्कोर 27.2 है।

1

क्या सामान्य क्वीन के नियम लागू होते हैं या प्रोग्राम को अपनी स्रोत फ़ाइल पढ़ने की अनुमति है?

— मार्टिन एंडर

1

सामान्य रानी नियम लागू होते हैं।

क्या मूल कोड बोनस की ओर गिना जाता है? इसी तरह, मूल कोड में एक मान्य होना चाहिए hello world?

— मार्टिन एंडर

1

मूल कोड बोनस की ओर गिना जाता है। मूल कोड में एक मान्य हैलो दुनिया नहीं है।

क्या आप उस नवीनतम नियम परिवर्तन के बारे में निश्चित हैं? साथ में "पहले कार्यक्रम में एक मान्य हैलो वर्ल्ड स्ट्रिंग शामिल नहीं है, या इसमें कई मान्य हैलो वर्ल्ड स्ट्रिंग्स शामिल हो सकते हैं।" मैं बोनस पाने के लिए मूल स्रोत कोड के लिए एक टिप्पणी के रूप में लापता बदलाव जोड़ सकता है (शायद ज्यादातर मामलों में इसके लायक नहीं है लेकिन फिर भी एक खामियों की तरह दिखता है)

— Fabian Schmengler

8

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

एक अलग अजगर समाधान:

"r\"helloworld\"1

आउटपुट:

r"helloworld"1

दूसरा आउटपुट:

HELLOWORLD

— फैबियन शेंगलर
स्रोत

नियम वर्तमान में "आपका कार्यक्रम विफल हो जाता है जैसे ही निम्नलिखित शर्तों में से एक पूरा हो जाता है: आउटपुट अब उसी भाषा में मान्य स्रोत कोड नहीं है" और "आपका कार्यक्रम इस प्रतियोगिता के लिए मान्य नहीं है जब तक कि कम से कम तीन पहले निष्पादन सफल नहीं होते हैं।" । पेल्थ में HELLOWORLD एक वैध कार्यक्रम है? यदि हाँ, तो कृपया इसका आउटपुट भी पोस्ट करें या बताएं कि यह क्या करता है। यदि नहीं, तो मुझे लगता है कि यह कार्यक्रम अमान्य है।

इसके अतिरिक्त, मैं स्पष्ट करना चाहता हूं कि यह कार्यक्रम समान स्ट्रिंग को दोहराने के बारे में नियम नहीं तोड़ता है। यह समाधान "हेलोवर्ल्ड" को दोहराता है जो पहले स्रोत कोड में था। नियम केवल एक स्ट्रिंग को दोहराने से मना करते हैं जो पिछले आउटपुट में रहा है। यदि दूसरा आउटपुट एक मान्य Pyth प्रोग्राम है, तो यह समाधान पूरी तरह से मान्य है।

जवाब देने के समय, नियम थे "आपका कार्यक्रम इस प्रतियोगिता के लिए मान्य नहीं है जब तक कि कम से कम दो प्रथम निष्पादन सफल न हों"

— फैबियन शेंगलर

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

9

गणितज्ञ, 214 - 50% = 107 बाइट्स

(a = Characters[StringJoin["helloworl", "d"]]; b = Apply[StringJoin, Tuples[Transpose[{a, ToUpperCase[a]}]], {1}]; StringReplacePart[ToString[#0, InputForm], b[[FirstPosition[b, "helloworld"] + 1]], {180, 189}]) &

मैंने यहां स्ट्रिंग गणना के लिए अनुकूलन करने का निर्णय लिया। यह बिना रोक-टोक और अपरकेस अक्षरों के हर संयोजन से गुजरते हुए 1024 कार्यक्रमों के लिए चलता है। निष्पादन को यहां देखा जा सकता है ।

— LegionMammal978
स्रोत

1

एक शर्म की बात है कि आप व्हॉट्सएप को बाहर नहीं कर सकते हैं और मैथेमेटिका के खानों में प्रीफिक्स और इन्फिक्स नोटेशन का उपयोग कर सकते हैं, है ना? ;) (काम के विपरीत विपरीत दृष्टिकोण के लिए यह काफी लंबा हो सकता है, जहां आप कोड को एक स्ट्रिंग में संग्रहीत करते हैं s, और इसके साथ मूल्यांकन करते हैं ToExpression।)

— मार्टिन एंडर

6

विट्टी, 33 - 33 * .05 * (11-2) = 18.15 बाइट्स

हे! को हराया! आप शायद करेंगे। :सी

पहला आउटपुट:

'0DV \ {25 ^ वी \}} {1 + Rd3 * जेड; HelloWorld
'स्ट्रिंग के रूप में कैप्चर करना शुरू करें
 0DV को स्टैक में 0 पुश करें और इसे अंतिम चर के रूप में सेट करें।
    \ अगली आइटम को कई बार दोहराएं। (1, 2, 3 ... आउटपुट पर।)
     {स्टैक को बाईं ओर घुमाएं।
      25 ^ स्टैक में 32 पुश करें।
         - इसके द्वारा शीर्ष आइटम को घटाएं - इससे लोअरकेस अपरकेस हो जाएगा।
          V \ N अगली आइटम अंतिम चर बार करें।
            } स्टैक को दाहिनी ओर घुमाएं।
             } और फिर...
              1+ एक जोड़ें। यह इस कोड में 0 को 1 बनाता है, फिर 2 ...
                stack स्टैक को उल्टा करें।
                 d3 * चरित्र प्राप्त करें '
                    Z स्टैक में सभी आइटम आउटपुट करें।
                     ; अंतिम निष्पादन।
                      helloworld हेरफेर करने के लिए स्ट्रिंग।

दूसरा आउटपुट:

'1DV \ {25 ^ वी \}} {1 + Rd3 * जेड; HelloWorld

तीसरा आउटपुट:

'2DV \ {25 ^ वी \}} {1 + Rd3 * जेड; HelloWorld

चौथा आउटपुट:

'3DV \ {25 ^ वी \}} {1 + Rd3 * जेड; HelloWorld

पांचवां आउटपुट:

'4DV \ {25 ^ वी \}} {1 + Rd3 * जेड; HelloWorld

छठा आउटपुट:

'5DV \ {25 ^ वी \}} {1 + Rd3 * जेड; HelloWorld

सातवां उत्पादन:

'6DV \ {25 ^ वी \}} {1 + Rd3 * जेड; HelloWorld

आठवां आउटपुट:

'7DV \ {25 ^ वी \}} {1 + Rd3 * जेड; HelloWorld

नौवां आउटपुट:

'8DV \ {25 ^ वी \}} {1 + Rd3 * जेड; HelloWorld

दसवां आउटपुट:

'9DV \ {25 ^ वी \}} {1 + Rd3 * जेड; HelloWorld

ग्यारहवां उत्पादन:

': डीवी \ {25 ^ वी \}} {1 + Rd3 * जेड; HelloWorld

यह अंतिम आउटपुट है, क्योंकि यह एक त्रुटि का कारण होगा।

— एडिसन क्रम्प
स्रोत

1

o_o सिम्प्लेक्स ने 21 तक संघर्ष किया। मैं 18.15 को हराकर काम करूंगा, हालांकि!

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ Vitsy व्यावहारिक रूप से अपने स्वयं के स्रोत कोड को संपादित करने और बुनियादी स्ट्रिंग हेरफेर करने के लिए बनाया गया था। XD मुझे लगता है कि यह अधिक नीचे गोल्फ हो सकता है, हालांकि।

— Addison Crump

मुझे लगा कि सिम्पलेक्स कमाल का होगा, क्योंकि इसमें एक बाहरी प्रोग्राम फंक्शन है, लेकिन नूको जो एक प्रोग्राम के रूप में गिना जाएगा। le sigh

— कॉनर ओ'ब्रायन

+1 करने के लिए +1 (या लगभग पिटाई) "क्लासिक" गोल्फिंग भाषाएँ

— ev3commander

@ ev3commander मैं उन्हें पीटा होता अगर यात्रा बोनस अधिक था। : c

— एडिसन क्रम्प

5

सीजाम, एन = 3 4, 28 बाइट्स - 10% - 10% = 22.4

{`_E=-"_~Hello!, World"2<}_~

यह निम्नलिखित श्रृंखला शुरू करता है:

{`_E=-"_~Hello, World"2<}_~
{`_E=-"_~Hello World"2<}_~
{`_E=-"_~HelloWorld"2<}_~
{`_E=-"_~Helloorld"2<}_~

जहां पिछले एक में अब एक मान्य "हैलो, वर्ल्ड" नहीं है।

इसका परीक्षण यहां करें।

व्याख्या

{`     e# Quine framework. Leaves a string representation of the block on the stack.
  _E=  e# Make a copy and get the 14th element, which is the character of the first 'o'.
  -    e# Remove that character from the string.
  "_~Hello!, World" e# Push this string, so the "Hello, World!" is part of the code.
  2<   e# Truncate to just "_~" to get the output right.  
}_~

ध्यान दें कि प्रारंभिक कार्यक्रम में एक मान्य "हैलो, वर्ल्ड" शामिल नहीं है, लेकिन यह हमें एक पुनरावृत्ति को आगे बढ़ाने की अनुमति देता है।

— मार्टिन एंडर
स्रोत

क्या यह -10% बोनस के लिए योग्य है? आउटपुट में केवल तीन मान्य विराम चिह्नों के दो होते हैं।

— माइक बुफर्देसी

@MikeBufardeci ओह अच्छा सवाल ... मुझे लगता है कि मूल कोड इसका हिस्सा था।

— मार्टिन एंडर

1

मैंने नियमों को स्पष्ट किया ताकि मूल कोड को बोनस के लिए गिना जाए। हालांकि मुझे मानना होगा कि मुझे महसूस नहीं हुआ कि यह -10% मिलना आसान है।

5

CJam 69 60 - 50% = 30

मैं अभी भी शुरुआती हूं, कृपया मुझे बताएं कि सीजेएम में गोल्फ कैसे करें।

{`_40>\40<_38>~)`2Te[\25<"helloworld"00YbATe[.{{el}{eu}?}`+]W%"_~"}_~

प्रत्येक पुनरावृति को प्रिंट करना थकाऊ है, क्योंकि यह 99 पुनरावृत्तियों के लिए मान्य होगा।

यह हैलो शब्द के कैपिटलाइजेशन को एनुमरेट करके काम करता है। टेडियम को "हेल्लो वर्ल्ड" के रूप में स्ट्रिंग्स में विभाजित करना है और काउंटर को अपडेट करना है।

व्याख्या

{`_40>\40<_38>~)`2Te[\25<"helloworld"00YbATe[.{{el}{eu}?}`+]W%"_~"}_~
{`                                                                      e# standard quine framework. Thanks for Dennis.
  _40>                                                                  e# get the Yb11..
      \40<                                                              e# get those that not included in top
          _38>~)`2Te[                                                   e# get the accumulator and increment it
                     \25<                                               e# get those before "hello world"
                         "helloworld"                                   e# the Hello World
                                     00                                 e# accumulator
                                        YbATe[                          e# convert to binary and align right.
                                              .{{el}{eu}?}              e# Uppercase if the corresponding bit is 0
                                                          `             e# add quote
                                                           +]W%         e# reorder stack
"_~"}_~

नोट: मैं गणितज्ञ उत्तर नहीं पढ़ता, क्षमा करें, मुझे लगता है कि यह मूल था

पुन: व्यवस्थित करने और अलग-अलग पूंजीकरण के साथ, मैं 9 बाइट खो देता हूं।

{`_6<\"helloworld"01YbW%.{{eu}{el}?}`\I>_2<~)`2Te[\2>"_~"}_~
{`                                                   "_~"}_~ e# Standard quine framework
  _6<\                                                       e# Get "{~_6<\"
      "helloworld"                                            e# The helloworld
                  01                                          e# The accumulator
                    Yb                                        e# Convert to base 2
                      W%                                      e# Reverse the binary
                        .{{eu}{el}?}                          e# Convert to uppercase while the corresponding bit is 1.
                                    `                         e# Add quote
                                     _2<                      e# Get accumulator
                                        ~)`2Te[               e# Increment the accumulator
                                               \2>            e# get the rest

सीजेएम 73 - 60% = 29.2

इस बार भी विराम चिह्न की गणना करें।

{`:Z6<"HELLOWORLD"0:AYbW%.{{eu}{el}?}`", ":B-_6<BA3%>@6>A)ZW%52<W%"_~"}_~
{`:Z                                                              "_~"}_~ e# Standard Quine Framework
    6<                                                                    e# take the first 6 character
      "HELLOWORLD"                                                        e# Hello, world
                  0:A                                                     e# Accumulator
                     YbW%.{{eu}{el}?}`                                    e# See above
                                      ", ":B                              e# Punctuation
                                            -                             e# Delete punctuation
                                             _6<                          e# "hello
                                                BA3%>                     e# punctuation
                                                     @6>                  e# world"
                                                        A)                e# incremented accumulator
                                                          ZW%52<W%        e# Remaining part

— Akangka
स्रोत

आपके पास एक अलग भाषा और एक छोटा उत्तर है, इसलिए गणित के उत्तर के समान दृष्टिकोण का उपयोग करने में कुछ भी गलत नहीं है।

ध्यान दें कि हम सबसे कम अंक की तलाश कर रहे हैं, न कि सबसे तेज़ पोस्टर या सबसे उपन्यास एल्गोरिथम की।

@ विले-वाल्टेरीटिटेनन स्टिल, मार्टिन बंटनर का जवाब अभी भी मुझसे कम है

— अकाँका

@ChristianIrwan तुम्हारा दिलचस्प है क्योंकि यह अलग-अलग पूँजी का उत्पादन करता है (और मुझे यकीन है कि यह मेरे पास पाने के लिए गोल्फ योग्य है या शायद इसे हरा भी सकता है, लेकिन मेरे पास अभी इसे विस्तार से देखने का समय नहीं है)।

— मार्टिन एंडर

4

गोल्फस्क्रिप्ट, 35 बाइट्स - 50% = 17.5

0"HelloWorld"{@@{^.32&\}%`@".~"}.~

मैंने एक दोहराने से पहले निष्पादन की संख्या पर ओवरकिल के लिए जाने का फैसला किया। यह कार्यक्रम, गोल्फ आउटपुट दुभाषिया में वापस आउटपुट के साथ, पहले दोहराने से पहले 890 अलग हैलो वर्ल्ड स्ट्रिंग्स का उत्पादन करेगा । एक संक्षिप्त नमूने के रूप में, यहाँ पहले 15 पुनरावृत्तियाँ हैं:

0"HelloWorld"{@@{^.32&\}%`@".~"}.~
0"HeLlOWoRlD"{@@{^.32&\}%`@".~"}.~
0"HelLOWorLD"{@@{^.32&\}%`@".~"}.~
0"HeLLOWoRLD"{@@{^.32&\}%`@".~"}.~
0"HellowORLD"{@@{^.32&\}%`@".~"}.~
32"HeLlOworld"{@@{^.32&\}%`@".~"}.~
0"hELloWoRlD"{@@{^.32&\}%`@".~"}.~
32"helLowORld"{@@{^.32&\}%`@".~"}.~
0"HeLLoWORlD"{@@{^.32&\}%`@".~"}.~
32"HellOWORld"{@@{^.32&\}%`@".~"}.~
0"hElLOWORlD"{@@{^.32&\}%`@".~"}.~
32"heLLOWORld"{@@{^.32&\}%`@".~"}.~
32"HelloworLd"{@@{^.32&\}%`@".~"}.~
32"hElLoWoRLd"{@@{^.32&\}%`@".~"}.~
0"HEllOWorlD"{@@{^.32&\}%`@".~"}.~

जिस तरह से यह काम करता है वह स्ट्रिंग के माध्यम से पुनरावृत्ति करता है, प्रत्येक अक्षर के कैपिटलाइज़ेशन को फ़्लिप करता है (32 के साथ अपने एएससीआईआई कोड को XOR करके) यदि पिछला पत्र (संभवतः इसके मामले में फ़्लिप होने के बाद) लोअरकेस है। पहला अक्षर इसके मामले में फ़्लॉप होगा यदि शुरुआत कार्यक्रम में संख्या 0 के बजाय 32 है - और अगले पुनरावृत्ति के लिए संख्या आउटपुट 32 होगा जब भी स्ट्रिंग के अंतिम अक्षर को कम किया जाता है, इस प्रकार अक्षरों के अंत में कोई परिवर्तन होता है अगले पुनरावृत्ति पर शुरुआत में वापस प्रचार करने के लिए स्ट्रिंग।

(यह विशेष रूप से प्रतिक्रिया प्रक्रिया पूरी तरह से तदर्थ तरीके से प्राप्त की गई थी । मैं मूल रूप से बिट्स के रूप में अपरकेस और लोअरकेस का उपयोग करके एक साधारण बाइनरी काउंटर चलाना चाहता था, लेकिन इसे लागू करने के लिए बहुत सारे बाइट्स लगे, इसलिए मैंने इसे कम खोजने के लिए ट्विक करना शुरू कर दिया। यह अभी भी काफी उच्च चक्र की लंबाई पैदा करेगा। चूंकि सैद्धांतिक अधिकतम, केवल केस-फ़्लिपिंग का उपयोग करते हुए, 2 ¹⁰ = 1024 है, 890-पुनरावृत्ति चक्र प्राप्त करना बहुत अच्छा है।)

काश, अतिरिक्त पुनरावृत्तियों के लिए बोनस ;50% पर छाया हुआ है; टोपी के बिना, इस कार्यक्रम में %4440% बोनस होगा। ;-)

— इल्मरी करोनें
स्रोत

3

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

"-\"hello world\"d

कौन सा रिटर्न:

-"hello world"d

जो बारी में प्रिंट:

helloworld

मेरे पास एक समाधान था जो सभी तीन वर्तनी करता था, लेकिन यह बोनस के साथ भी लंबा है।

— माइक बुफ़र्डेकी
स्रोत

ध्यान दें कि जब तक नियमों को तीन के बजाय दो पुनरावृत्तियों की आवश्यकता होती है, तब तक यह उत्तर संक्षिप्त रूप से अमान्य था। यह अब फिर से मान्य है, हालांकि।

— DL33 6'15

3

सिंप्लेक्स , 21 बाइट्स।

यह वही है जो सिम्पलेक्स के लिए पैदा हुआ था । मैं निश्चित रूप से इससे आगे जा सकता हूं।

(मैं Ctrl + Enter दबाकर रखता हूं, क्षमा करें! मैं इसे टेबलेट कीबोर्ड पर दोष देता हूं)

प्रयास 3, v.0.8 +, 31 -5% = 29.45 बाइट्स (UTF-8 मैथिंक)

बीच में वह भाव स्वयं को व्यक्त करता है। की तरह। मैंने ऐसा क्यों किया, फिर से? ._।

"\"f[helloworld]-:D-``\"§R'Hg"g
"                            "  ~~ write that string
 \"f[helloworld]-:D-``\"§R'Hg   ~~ escaped quotes
                              g ~~ output that string

दूसरा आउटपुट:

"f[helloworld]-:D-``"§R'Hg
"                   "      ~~ write that string
 f[helloworld]-:D-``       ~~ string to be written
                     §R    ~~ go to second cell
                       'H  ~~ set it to H charcode
                         g ~~ output that string

तीसरा आउटपुट:

f[Helloworld]-:D-``
f                   ~~ turns off safety mode (heck yeah error suppression!)
 [          ]-      ~~ write inside to outer program
  H                 ~~ sort strip
   e                ~~ write e = 2.718281828459045... to the strip
    ll              ~~ writes 1 twice to the cell
      o             ~~ outputs 1
       wo           ~~ apply o backwards through the strip (outputs 1)
         r          ~~ error! tries to access register for modification. nope!
          l         ~~ write 1 to to the current cell
           d        ~~ reverse the strip (NOP)
              :     ~~ removes last char of outer program
               D    ~~ double the current byte (2)
                -   ~~ writes previous char to outer program
                 `` ~~ suppress outer program evaluation and instead output it

अंतिम आउटपुट:

HelloworlD

प्रयास 2, v.0.8 +, 21 बाइट्स (UTF-8, मुझे लगता है)

"\"helloworld\"§'Hg"g
"                  "  ~~ write that string
 \"helloworld\"§'Hg   ~~ escaped quotes
                    g ~~ output that string

आउटपुट:

"helloworld"§'Hg
"          "     ~~ write that string
 helloworld      ~~ string to be written
            §    ~~ go to first cell
             'H  ~~ set it to H charcode
               g ~~ output that string

अंतिम आउटपुट:

helloworld

प्रयास 1, v.0.7 + 28 26 बाइट्स

मुझे यकीन नहीं है कि यह पहले बोनस के लिए योग्य है ...

"BhelloworldB"t[s32S;]'gs;
"            "             ~~ write that string
 BhelloworldB              ~~ the string
              t[     ]     ~~ apply the inner from left to right
                s          ~~ output as character
                 32S       ~~ subtract 32 ("capitalize")
                    ;      ~~ add the current byte's char to the outer program
                      'g;s ~~ add g to the outer program

पहला आउटपुट:

"HELLOWORLD"g

निष्पादन के अंत में बाहरी कार्यक्रम का मूल्यांकन किया जाता है (यह इसे y के लिए करता है; बाहरी कार्यक्रम ऐसा दिखता है:

"HELLOWORLD"g
"          "  ~~ write that string
            g ~~ output that string as string characters

अंतिम आउटपुट:

HELLOWORLD

— कोनोर ओ ब्रायन
स्रोत

क्या यह कार्यक्रम -50% बोनस के लिए योग्य है? ऐसा लगता है कि यह हो सकता है, लेकिन आपने कोई आउटपुट पोस्ट नहीं किया है।

@ विले-वाल्टेरीटिटेनन यह केवल दो बार चलता है। मैं इस समय बोनस पर काम कर रहा हूं।

— कॉनर ओ'ब्रायन 18

2

रूबी, 81 - 50% = 40.5

मूल कोड:

_='_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)';puts _%[_,'HELLOWORL'+?D]

क्रमिक आउटपुट:

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"HELLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hELLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"heLLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hellOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hellowORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hellowoRLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloworLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloworlD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloworld"]).sub(/[[:upper:]]/,&:swapcase)

मुझे लगता है कि यह पूर्ण 50% के रूप में गिना जाता है? एक से दूर हो सकता है। इसके अलावा, रूबी में एक बेहतर स्कोरिंग गैर-बोनस समाधान है।

मूल कोड में "helloworld" शामिल नहीं है, लेकिन यह एक क्वीन बनाता है जो निचले स्रोत संस्करण के साथ अपने स्रोत कोड में पहले कैपिटल लेटर को बदलता है। तो क्वीन के प्रत्येक क्रमिक रन में एक कम पूंजीकृत अक्षर होता है।

यहाँ ट्रिक यह है कि क्विनिंग और हैलो वर्ल्ड स्ट्रिंग के लिए दोनों स्ट्रिंग को इंटरपोल करने के लिए एक फॉर्मेट स्ट्रिंग का उपयोग किया जाए, ताकि यह केवल एक बार दिखाई दे।

— histocrat
स्रोत

1

PHP, 297 - 40% = 178.2 बाइट्स

वास्तव में प्रतिस्पर्धी नहीं लेकिन यह लिखने में मजेदार था

<?ob_start(function($s){$s=substr(str_replace(0,0+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[0]=$h[0]^' ';return "<"."?".$s."?".">".$s.$h;});?>ob_start(function($s){$s=substr(str_replace(0,0+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[0]=$h[0]^' ';return "<"."?".$s."?".">".$s.$h;});

यह इस क्वीन की एक भिन्नता है:

<?
ob_start(function($b){ return "<"."?\n$b?".">\n$b"; });?>
ob_start(function($b){ return "<"."?\n$b?".">\n$b"; });

लेकिन यह आउटपुट में "helloworld" भी जोड़ता है और इसके 0साथ 0+1(अगले पुनरावृत्ति 1में 1+1और इतने पर) के साथ बदल देता है । substrकिसी भी मौजूदा "हेलोवर्ल्ड" आउटपुट का उपयोग करने से पहले नए "हेलोवर्ल्ड" को जोड़ा जाता है।

अलग-अलग आउटपुट प्राप्त करने के लिए, "हेलोवर्ल्ड" का एक अक्षर बड़ा हो जाता है (वेतन वृद्धि संख्या द्वारा निर्धारित)। यह प्रासंगिक कोड है:

$h=hello.world;$h[0]=$h[0]^' '

एक चुनौती यह थी कि यहां और नंबर बदलने के अलावा किसी भी नंबर का इस्तेमाल न किया जाए

str_replace(0,0+(int)true,$s)

वहाँ आप पहले से ही देख रहे हैं कि के +1रूप में एहसास हुआ है +(int)true।

प्रतिस्थापन तर्क के लिए मुझे चाहिए 0, 146:

!i, ord(I)+ord(I)

गैर-रिक्त स्ट्रिंग "i" के लिए मजबूर trueऔर उपेक्षित हो जाता है। falseएक मान्य पूर्णांक तर्क है और जैसा माना जाता है 0। ord(I)"I" का ASCII मान है: 73

आउटपुट (प्रथम पुनरावृत्ति):

<?ob_start(function($s){$s=substr(str_replace(1,1+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[1]=$h[1]^' ';return "<"."?".$s."?".">".$s.$h;});?>ob_start(function($s){$s=substr(str_replace(1,1+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[1]=$h[1]^' ';return "<"."?".$s."?".">".$s.$h;});Helloworld

आउटपुट (दूसरा पुनरावृत्ति):

<?ob_start(function($s){$s=substr(str_replace(2,2+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[2]=$h[2]^' ';return "<"."?".$s."?".">".$s.$h;});?>ob_start(function($s){$s=substr(str_replace(2,2+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[2]=$h[2]^' ';return "<"."?".$s."?".">".$s.$h;});hElloworld

आउटपुट (10 वां पुनरावृत्ति):

यह अंतिम वैध आउटपुट है, लेकिन अब एक वैध कार्यक्रम नहीं है

<?ob_start(function($s){$s=substr(str_replace(10,10+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[10]=$h[10]^' ';return "<"."?".$s."?".">".$s.$h?>ob_start(function($s){$s=substr(str_replace(10,10+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[10]=$h[10]^' ';return "<"."?".$s."?".">".$s.$hhelloworlD

"हैलो वर्ल्ड" स्ट्रिंग्स खोजने के लिए दाईं ओर स्क्रॉल करें!

— फैबियन शेंगलर
स्रोत

बस एहसास हुआ कि मैं (int)true`` !! i` को बदल सकता हूं और 12 बाइट बचा सकता हूं। इसे थोड़ा और बाद में गोल्फ करने की कोशिश करेंगे

— फैबियन शेंगलर

1

पिप, 48 - 50% = 24

V Y"`V Y`.RPyRh:ST`helloworld`UCh@<0.h@>0R0o+0"

जो निम्नानुसार विकसित होता है:

V Y"`V Y`.RPyRh:ST`helloworld`UCh@<1.h@>1R1o+1"
V Y"`V Y`.RPyRh:ST`Helloworld`UCh@<2.h@>2R2o+2"
V Y"`V Y`.RPyRh:ST`HElloworld`UCh@<3.h@>3R3o+3"
V Y"`V Y`.RPyRh:ST`HELloworld`UCh@<4.h@>4R4o+4"
V Y"`V Y`.RPyRh:ST`HELLoworld`UCh@<5.h@>5R5o+5"
V Y"`V Y`.RPyRh:ST`HELLOworld`UCh@<6.h@>6R6o+6"
V Y"`V Y`.RPyRh:ST`HELLOWorld`UCh@<7.h@>7R7o+7"
V Y"`V Y`.RPyRh:ST`HELLOWOrld`UCh@<8.h@>8R8o+8"
V Y"`V Y`.RPyRh:ST`HELLOWORld`UCh@<9.h@>9R9o+9"
V Y"`V Y`.RPyRh:ST`HELLOWORLd`UCh@<10.h@>10R10o+10"
V Y"`V Y`.RPyRh:ST`HELLOWORLD`UCh@<11.h@>11R11o+11"
V Y"`V Y`.RPyRh:ST`HELLOWORLD`UCh@<12.h@>12R12o+12"

अंतिम आउटपुट अमान्य होने के कारण HELLOWORLDपरिवर्तित नहीं हुआ है। (अगर मैंने बोनस सही नहीं किया है तो मुझे सुधारें।)

इस सवाल के लिए धन्यवाद, मैंने अभी एक नई क्वीन तकनीक की खोज की है! बेस क्वीन है V Y"`V Y`.RPy":

  Y"         "  Yank that string into the variable y
V               Evaluate it as a Pip expression:
          RPy   y wrapped in double quotes (repr)
    `V Y`.      Prepend that regex pattern
                When this is evaluated, it returns a pattern object, which is
                auto-printed--conveniently, without the `` delimiters

हमारा अतिरिक्त कोड स्ट्रिंग को संशोधित करता है y, इसे repr-ing करने से पहले, निम्नानुसार है:

वर्तमान हेलोवर्ल्ड को एक के साथ बदलें जिसमें सबसे बाएं 0अक्षर बड़े हैं;
के 0साथ होने वाली सभी घटनाओं को बदलें o+0(जहां oएक बिलियन वैरिएबल है जो 1 के बराबर है)।

अगली बार कोड में संख्या के 1बजाय 0और इसके आगे है।

— DLosc
स्रोत

1

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

function(){return '("hello world").replace(" ","")'}

परीक्षा

=>

<='("hello world").replace(" ","")'

=> eval('("hello world").replace(" ","")')

<= 'helloworld'

— Fuzzyzilla
स्रोत

1

///, 23 बाइट्स - 10% = 20.7?

/,//\/ \/\/hello, world

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

पहला आउटपुट:

/ //hello world

दूसरा आउटपुट:

helloworld

— धनुराशि
स्रोत

बोनस दो से अधिक पुनरावृत्तियों के लिए है, इसलिए आपका स्कोर अभी भी 23 बाइट्स है

— जो किंग

1

बीबीसी बेसिक, 56 बाइट्स

मुझे इस बात का आभास हो गया था कि मुझे इस बात का अहसास है कि मैं इस खेल में कितनी देर से हूं। इसके लायक क्या है, यहां मेरा संस्करण और StackExchange कोड गोल्फ में मेरा पहला प्रयास है।

यहाँ, V. निम्नलिखित अल्पविराम से अलग की गई सूची में ASCII कोड द्वारा दिए गए वर्णों को निकालता है और P. प्रिंट के लिए शॉर्टहैंड करता है। मैं मौजूदा 'हेलोवर्ल्ड' स्ट्रिंग को अधिलेखित करने के लिए बैकस्पेस चरित्र का उपयोग करता हूं।

इनपुट कोड:

V.80,46,34:P."helloworld";:V.8,68,34,59:P.":V.8,8,76,68"

पहला आउटपुट:

P."helloworlD";:V.8,8,76,68

दूसरा आउटपुट:

helloworLD

इसे https://bbc.godbolt.org/ पर ऑनलाइन परीक्षण किया जा सकता है

— एंड्रयू पॉल
स्रोत

मैंने बीबीसी बेसिक का इस्तेमाल कभी नहीं किया है, लेकिन इसका परीक्षण कैसे किया जा सकता है? यदि मैं इसे लिंक किए गए एमुलेटर में पेस्ट करता हूं, तो अंतिम पंक्ति मेरे लिए "गलती" का उत्पादन करती है।

— मेरा सर्वनाम

मैं अपना उत्तर स्पष्टता के लिए संपादित करूँगा। यह सिर्फ पहली पंक्ति है जिसमें चिपकाने की आवश्यकता है। पीसी, कर्सर और 'एंड' कुंजियों का उपयोग करके एमुलेटर में दूसरी, उत्पन्न लाइन को कॉपी और निष्पादित किया जा सकता है। तीसरी पंक्ति को नियमों के अनुसार अमान्य होने की अनुमति है।

— एंड्रयू पॉल

"हैलो वर्ल्ड" जो एक अलग "हैलो वर्ल्ड" प्रोग्राम बनाता है

उदाहरण

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

गणितज्ञ, 214 - 50% = 107 बाइट्स

विट्टी, 33 - 33 * .05 * (11-2) = 18.15 बाइट्स

पहला आउटपुट:

दूसरा आउटपुट:

तीसरा आउटपुट:

चौथा आउटपुट:

पांचवां आउटपुट:

छठा आउटपुट:

सातवां उत्पादन:

आठवां आउटपुट:

नौवां आउटपुट:

दसवां आउटपुट:

ग्यारहवां उत्पादन:

सीजाम, एन = 3 4, 28 बाइट्स - 10% - 10% = 22.4

व्याख्या

CJam 69 60 - 50% = 30

सीजेएम 73 - 60% = 29.2

गोल्फस्क्रिप्ट, 35 बाइट्स - 50% = 17.5

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

सिंप्लेक्स , 21 बाइट्स।

प्रयास 3, v.0.8 +, 31 -5% = 29.45 बाइट्स (UTF-8 मैथिंक)

प्रयास 2, v.0.8 +, 21 बाइट्स (UTF-8, मुझे लगता है)

प्रयास 1, v.0.7 + 28 26 बाइट्स

रूबी, 81 - 50% = 40.5

PHP, 297 - 40% = 178.2 बाइट्स

आउटपुट (प्रथम पुनरावृत्ति):

आउटपुट (दूसरा पुनरावृत्ति):

आउटपुट (10 वां पुनरावृत्ति):

पिप, 48 - 50% = 24

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

परीक्षा

///, 23 बाइट्स - 10% = 20.7?

बीबीसी बेसिक, 56 बाइट्स