नमस्ते दुनिया! अर्ध-सामान्य पात्रों के साथ


28

जैसा कि आप में से कुछ को पता है, डेनिस के अद्भुत कोशिश ऑनलाइन पर एक भाषा पाने के लिए ! , एक हैलो, विश्व! कार्यक्रम की आवश्यकता है। हाल ही में, डेनिस ने इन कार्यक्रमों को वेबसाइट से लोड करने का एक तरीका निकाला। 27 जुलाई, 2017 तक, आवृत्ति द्वारा, उन कार्यक्रमों में उपयोग किए जाने वाले वर्णों का एक JSON पास्टबिन है।

उन पात्रों में से कुछ को कुछ प्यार की आवश्यकता है, इसलिए आपकी चुनौती हैलो, वर्ल्ड आउटपुट करना है! (अधिमानतः इस प्रक्रिया में शामिल भाषा में), केवल नीचे निर्दिष्ट वर्णों का उपयोग करते हुए। ये पात्र उन सभी पात्रों के बीच 10और 99(समावेशी) समय का उपयोग करते हैं, साथ ही दो सबसे सामान्य पात्रों के साथ, 0और , क्योंकि मैं अच्छा महसूस कर रहा हूं।

0 $&*?ABCDEFGIJKLNPQRSTUXYZ\`gjkqwxyz{}÷≤≥=║_

चरित्र का आपका उपयोग एक सामान्य कार्यक्रम में उसके स्वरूप पर आधारित होना चाहिए, न कि उसके कोड बिंदु या बाइट मूल्य के आधार पर।

आपको उस सेट से कम से कम एक वर्ण का उपयोग करना होगा, इसलिए 0-लंबाई के कार्यक्रम अमान्य हैं।

यह , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।

यदि आपका उत्तर मान्य है, तो जाँच करने के लिए JSFiddle


क्या मैं अगली पंक्ति में जगह बना सकता हूं?
दिजिमा

@dzaima यदि आप इसे स्पेस के बिना आउटपुट नहीं कर सकते हैं, तो इसे करें। यदि अंतरिक्ष से छुटकारा पाने के लिए बस अधिक बाइट्स का उपयोग किया जाता है, तो अंतरिक्ष से छुटकारा पाएं
स्टीफन

क्या गैर-मुद्रण पात्रों पर एक सामुदायिक आम सहमति (या विशिष्ट डिस / भत्ता) आउटपुट (STDOUT) में अपना रास्ता बना रहा है? यकीन नहीं है कि मैंने इसे पहले देखा है (और इसे आसानी से नजरअंदाज कर दिया जाएगा), लेकिन यह मेरी रणनीति को नाटकीय रूप से यहां बदल देता है ...
brhfl

@brhfl नहीं कि मुझे पता है - एकमात्र मानदंड यह है कि अनुगामी न्यूलाइन्स को आमतौर पर अनुमति दी जाती है, आप चैट में पूछ सकते हैं
स्टीफन

जवाबों:


6

SOGL V0.12 , 89 75 68 बाइट्स

z{}xxxx≥x≥x≥xXUqXxq≤qq≤q *R_IIRq  q *R_I0II*IRqxXq≤qxqxq CR_0II÷Rq0*

यह कोशिश करो!
नोट: जब भी qया आउटपुट को यहां संदर्भित किया जाता है, तो यह पॉपिंग आउटपुट के रूप में पॉप नहीं होता है (कोई भी oOpP) अनुपलब्ध है या आउटपुट एक प्रीपेड न्यूलाइन है।

स्पष्टीकरण (पुराना, जो बदल गया है वह यह है कि "H" वर्णमाला अक्षरों का उपयोग करके मुद्रित किया गया है):

 $             push "$"
  R_           convert to an array of ordinals, then push all the contents to the stack
    0II        push 0+1+1 = 2
       *       multiply by that
        R      convert to character
         q     output
          z    push the lowercase alphabet
           {}  iterate over it, pushing each char, and do nothing. Stack: ["H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
stack manipulation:
 xxxx ["H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r"]
 ≥    ["r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q"]
 x    ["r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o"]
 ≥    ["o","r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n"]
 x    ["o","r","H","a","b","c","d","e","f","g","h","i","j","k","l"]
 ≥    ["l","o","r","H","a","b","c","d","e","f","g","h","i","j","k"]
 xxx  ["l","o","r","H","a","b","c","d","e"]
 q    output the "e"
 ≤    ["o","r","H","a","b","c","d","e","l"]
 qq   output the "l" twice
 ≤    ["r","H","a","b","c","d","e","l","o"]
 q    output the "o"

*                       push "*",
 R_                     convert to an array of ordinals, then push all to stack
   II                   increase by 2
     R                  convert back to character
      q                 output
         q              push a space, then output
           *            push "*"
            R_          convert to an array of ordinals, then push all to stack
              I         increase that
               0II      push 0+1+1 = 2
                  *     multiply
                   I    increase
                    Rq  output as character
stack manipulation: (starting stack: ["r","H","a","b","c","d","e","l","o",","," ","W"])
 x  ["r","H","a","b","c","d","e","l","o",","]
 X  ["r","H","a","b","c","d","e","l","o"]
 q  output the "o"
 ≤  ["H","a","b","c","d","e","l","o","r"]
 q  output the "r"
 x  ["H","a","b","c","d","e","l"]
 q  output the "l"
 x  ["H","a","b","c","d"]
 q  output the "d"

C            push "C"
 R_          convert to ordinal as before
   0II÷      floor divide by 2
       Rq    output as character
         0*  multiply by 0 so nothing extra would be outputted

मजेदार तथ्य: अनुमत वर्णों के सभी अक्षर SOGLs कोडपेज: D में हैं


तो ... आपके पास पेशेवर डेवलपर के रूप में एक अच्छा स्थिर काम है? क्योंकि खतरे, यह एक शांत भाषा है ... बहुत अच्छा जेएस दुभाषिया, आपने इसे कल रात समाप्त कर लिया :)? क्या आप कुछ भाषा के लिए दस्तावेज़ पोस्ट करना शुरू कर सकते हैं? या निजी-चैट मुझे इस तरह के प्रलेखन का स्थान बताता है? एसओजीएल ने इसे मार दिया।
मैजिक ऑक्टोपस Urn

@MagicOctopusUrn 1) नहीं lol मैं 15 2 हूँ) मुझे व्यक्तिगत रूप से यह पसंद नहीं है जिस तरह से इसे बनाया जाता है वह सबसे अजीब चीज है जिसे मैंने 3 बनाया है) जेएस दुभाषिया को थोड़ी देर के लिए 4 हुए हैं) नवीनतम डॉक्स एसओजीएल (यदि आप उन्हें कॉल कर सकते हैं) यहाँ हैं , तो कुछ सामान palenChars.txt
गर्तें

फिर से बाइट काउंट कम करने पर बधाई! मैं ईमानदारी से नहीं सोचता कि मैं किसी भी कम प्राप्त कर सकता हूँ !!
डोम हेस्टिंग्स

23

पर्ल 5 , 76 बाइट्स

}{${$_=$`x?B?}{?\w$?}{$_=qq{Lg\LLL$&= w$&RLD=}&qq=y}\LLL$&L _$&RLDA=}=$_=\*G

यह एक ऐसी सुविधा का उपयोग करता है जिसे हटा दिया गया है, लेकिन मेरे टर्मिनल में स्थानीय रूप से काम करता है (जो संस्करण 5.18.2 संस्करण के रूप में विख्यात है)। पर्ल के पुराने संस्करणों में ?\w?एक पर्यायवाची है /\w/जिसके लिए मुझे रेग्जिप मिलान से अभिगम मिलता है और मेरे पास $&(अंतिम मैच) और $`(पिछले मैच से पहले का पाठ ) के लिए पर्याप्त वर्ण हैं । मैं इन पाने के लिए सक्षम होने की जरूरत है O। मैं इसे एक globसंदर्भ ( $_=\*Gजो, एक स्केलर को कास्ट, कुछ ऐसा हैGLOB(0x7ffb728028d0) ) बना रहा हूं । एक बार जो अंदर होगा $_, ?B?वह मेल खाएगा Bऔर$` शामिल होंगे GLO, मैं तो मेल खाते के खिलाफ कर सकते हैं \w$जो संग्रहीत करेंगे Oमें$&जिसे स्ट्रिंग में डाला जाता है, जो मैं स्ट्रिंगवाइज़ चला रहा हूँ-और बाकी टेक्स्ट बनाने के लिए, स्ट्रिंग के बॉडी को नीचे की तरफ इस्तेमाल किया जाता है \L

इसे ऑनलाइन आज़माएं! - TIO पर पर्ल के संस्करण के /\w/स्थान पर उपयोग ?\w?बहुत नया है।


पर्ल 5 , 65 बाइट्स

यह थोड़ा अधिक धोखा है क्योंकि यह TIO (जो है .code.tio) पर फ़ाइल नाम पर निर्भर करता है , इसलिए मुझे नहीं लगता कि यह प्रतिस्पर्धा है, लेकिन मैं परिणाम से खुश था!

}{${$_=$0}{?\w$?}{$_=qq{Lg\LLL$&= w$&RLD=}&qq=y}\LLL$&L _$&RLDA=}

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


मैंने झंडे की सामग्री के बारे में कुछ नहीं कहा, इसलिए -pठीक है। अच्छा काम, यह वही है जो मैं यह पूछने के लिए उम्मीद कर रहा था :)
स्टीफन

1
कैसे ... क्या ... ...
15

@ स्टीफन मुझे खुशी है कि मैं बाध्य हूं! मैंने ईमानदारी से इसका आनंद लिया। मुझे खुशी है कि आप ध्वज को दंडित नहीं कर रहे हैं, मैं अपनी पोस्ट को अपडेट करूंगा। धन्यवाद!
डोम हेस्टिंग्स

@Okx मुझे इसका प्रभाव पड़ा है!
डोम हेस्टिंग्स

आप सुनिश्चित करें कि आपको 15 बाइट्स जोड़ने की आवश्यकता नहीं है <3?
मैजिक ऑक्टोपस Urn

10

यूनरी , 7 * 10 182 बाइट्स

Unary Brainfuck है जो बाइनरी में परिवर्तित 0होकर काउंटर के रूप में उपयोग करके unary में परिवर्तित हो गया है। अनिवार्य रूप से, यह एक ब्रेनफक प्रोग्राम को एक संख्या में सम्मिलित करता है और आउटपुट उस संख्या का होता है 0। वे आम तौर पर बहुत बड़े कार्यक्रम होते हैं।

मैं इस कार्यक्रम को यहाँ नहीं रखूँगा क्योंकि मुझे नहीं पता कि SE कितना पाठ की अनुमति देता है लेकिन मुझे यकीन है कि यह इससे कम है। इसके बजाय, मैं इस उत्तर में शून्य की सटीक संख्या चिपकाऊंगा:

708184005756841022918598670049178934705323143517361395031673227349803938380119378597780037353721967636097362645175347036417214959141923667629285233360306016978751166690464736541968556

जैसा कि यह एक काफी सस्ता जवाब है, कम से कम नहीं होने की गारंटी है, और मैंने बस इसे कॉपी किया है, मैं इसे विकी पोस्ट बना रहा हूं।


2
"मुझे नहीं पता कि एसई कितना पाठ की अनुमति देता है" कम से कम यह 7 * 10 much नहीं है जो कि 65536 से बड़ा वाया है।
आउटगॉल्फ

9

05AB1E , 137 106 95 बाइट्स

X00X00DXX00DXX00XX0X0X00D0XXXX0X00X00XXX00XXX0XXXXXX00XXXXX0XXXX00D0X000DD00XXJC000gDD0000g***B

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

-31 धन्यवाद @ इंगित करने के लिए कि मैं आधार 108 का उपयोग कर सकता हूं।

- ?? कुछ बातों को गलत बताने के लिए @ रिले का शुक्रिया।


पुराना संस्करण (भिन्न विधि):

05AB1E , 211 186 166 बाइट्स

0g00g000000000gUX000000gXX00000g000g00g000gD0000g0 000g00000gX00000gX00000g0 00000g00000000g0000000g00g00000000gD000000gX0000000g0g00000gUXJX00000000000000000g000g**B

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


Haha! और मैं यहाँ उन लोगों को एक अच्छा प्रदर्शन पसंद करता हूँ!


सबसे पहले हम एक्स में संग्रहित 255:

00g               # Push 2 (length of 00).
   00000g         # Push 5 (length of 00000).
         00000g   # Push 5.
               JU # Join to 255 and store in X.

फिर, उसी लंबाई की चाल का उपयोग करके हम धक्का देते हैं: 1296995323340359595058728869715

0g00g000000000g000000g000000000g000000000g00000g000g00g000g000g0000g0 000g00000g000000000g00000g000000000g00000g0 00000g00000000g0000000g00g00000000g00000000g000000g000000000g0000000g0g00000gJ

जहां हम सिर्फ 0<space>शून्य के लिए लंबाई चाल के बजाय उपयोग करते हैं।

फिर, अंत में, हम 255 को संग्रहीत करते हैं और 255 से बेस 10 में परिवर्तित करते हैं :

X  # Push stored 255.
 B # Convert to base 255.

फिर भी अन्य अनुमत वर्णों और दोहराव का उपयोग करके गोल्फिंग करना, यह एक मिनट होगा।


8

बीटनिक , 148 बाइट्स

K QQQQQQQG ZD XA K QQJA KD ZD XA K KG KD ZD ZD ZD XA XA K B KD ZD XA K QQQQF ZD ZD XA K QQQD XA K A Z KD XA ZD XA K B KD XA ZD XA K J Z XA K QQQB XA

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

व्याख्या

बीटनिक शब्द के स्क्रैबल स्कोर के आधार पर निष्पादित अनुदेश को आधार बनाता है। यहाँ एक छोटा स्पष्टीकरण दिया गया है:

Code         Scrabble Score   Explanation

K            5                push the scrabble score of the next word
QQQQQQQG     72               72 ['H']
ZD           12               pop a value; push it back twice
XA           9                pop a value; print its ASCII character
KD           7                pop two values; push their sum
Z            10               pop two values; push their difference

8

मूरहेंस (v2.0), 3423 983 923 866 749 716 बाइट्स

मुझे लगता है कि यह थोड़ा गोल्फ हो सकता है, Moorhens के साथ काम करने के लिए एक आसान भाषा नहीं है।

xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU KA AA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU KA KA xU xU xU AA AA AA AA AA KA xU AA KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU KA XI XI XI XI XI XI KA XI XI XI XI XI XI XI XI AA AA AA AA AA AA AA AA AA AA AA AA

व्याख्या

मूरहेंस एक शब्द है जो डिक्शनरी शब्दों पर आधारित है। प्रत्येक शब्द अपने हैश के आधार पर एक ऑपरेशन से मेल खाता है। यहां इस्तेमाल पाँच संचालन कर रहे हैं xU, ER, XI, KA, औरAA

  • xU टीओएस को बढ़ाता है
  • ER स्टैक पर एक नया शून्य डालता है।
  • XI टीओएस को घटाता है
  • KA टीओएस नकल करता है
  • AA नीचे से टीओएस रोल करता है

हम प्रत्येक पत्र को इन परिचालनों के पर्याप्त अनुप्रयोगों के साथ आगे बढ़ाते हैं।


5
'द टू ऑपरेशंस' - मैं अच्छी तरह से एसोलैंग्स में निपुण नहीं हूं, लेकिन निश्चित रूप से वे पांच ऑपरेशन हैं।
9


1
भाषा से लिंक?
लीक

मुझे लगता है कि यह ऐसा है। github.com/Wheatwizard/Moorhen
पुनरावर्ती

5

ग्लाइफो , 480 बाइट्स

AABCABABABBAABABAABCABBAABABABBCABBAABABABABABABABBAABBAABABABABABABABBAABBAAABCABBAABABAABCAABCABBAABABABBCABABABBAABBAABABAABCAABCABBAAABCABBAABABABBAABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABAAABABAABAABBAABCAABABABBAABBAAABCAABCABBAABABABBCABABABBCABABABBAABAAABABAABAABABABBAABABABBAABABABAAABABAABAABBAABABABBAAABCABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABCAABAAABABAABAABBAABABABBCAABCABBAAABCAABCABBAAABCABBAABABABBAABABABBCABABABBAABAAABABABCAABBAAABAABACABBBABCB

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



4

डबल जावास्क्रिप्ट, 318 बाइट्स

मुझे यकीन नहीं है कि अगर इसकी अनुमति है, तो मैं एक बार जावास्क्रिप्ट दुभाषिया का उपयोग करके ऐसा नहीं कर सकता। यह उपयोग करने के समान है, eval()लेकिन इसके बजाय मैं दुभाषिया का दो बार उपयोग कर रहा हूं: (परिणाम को वापस मुद्रित करने के लिए कंसोल में आज़माएं)

`\`\\x${0xA*0xA&0xC}${0xA&0xC}\\x${0xA*0xF&0xF}${0xB*0xF&0xF}\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}F\\x${0xE*0xF&0xF}C\\x${0xE*0xF&0xF}${0}\\x${0xB*0xF&0xF}${0xB*0xB*0xF&0xF}\\x${0xA*0xF&0xF}F\\x${0xB*0xB*0xF&0xF}${0xE*0xF&0xF}\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}${0xA*0xA&0xC}\\x${0xE*0xF&0xF}${0**0}\``

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

का मूल्यांकन:

`\x48\x65\x6C\x6C\x6F\x2C\x20\x57\x6F\x72\x6C\x64\x21`

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

जिसका मूल्यांकन करता है Hello, World!


3

Smallf ** k , 266 बाइट्स:

zJ$NJ`ZZx*gQYQQ{zqyKKUkUR?AS`zB`JB&UCKCIxQ_G0*000FzzJ&?YwkC\qqgZ`xYQyC}DgY_&_S}KPZ\&?SGAE&{Gw_w} GAgA{qT{gC&`qI?xwCNQwgR}?{*QEwQUj&BT&jR__IJJIqUqAPF0yICXESL?AYR QIAFU& yYwE&$\Njj B0T*F j$?kCzQk*}U}UgI$}Ew_yDL`qYI*E_G}SCjXDFNJKGNIGyIwA\BzLP`*zCILGCNqyYZyq? GwN{q{gKSj

दरअसल, अक्षर थोड़े अप्रासंगिक हैं। यह सिर्फ एक बात है कि क्या प्रत्येक वर्ण का एक समान कोडपॉइंट या विषम कोडपॉइंट है या नहीं। इस प्रकार, मैंने उपलब्ध हर चरित्र का उपयोग करने का प्रयास किया है (मल्टीबैट पात्रों को छोड़कर) (हालांकि जब से इसे यादृच्छिक किया गया था, मैंने उस गारंटी की कोशिश नहीं की)।


1
@totallyhuman तुम सही हो; मैं उसे बदल दूंगा। मैं सिर्फ मल्टीबाइट पात्रों को हटा दूँगा। यह वास्तव में एक कोडपेज नहीं है; इसे केवल 1s और 0s (विषम के लिए 1 ordऔर यहां तक ​​कि 0 के लिए ord) के रूप में संग्रहीत करने की आवश्यकता है, इसलिए आप यह कह सकते हैं कि यह 33.25 बाइट्स xD है
हाइपरनेट्रीनो

चरित्र का आपका उपयोग एक सामान्य कार्यक्रम में उसके स्वरूप पर आधारित होना चाहिए, न कि उसके कोड बिंदु या बाइट मान के आधार पर।
केस्मार्ट

@KSmarts मैं उस बारे में ओपी से पूछूंगा।
हाइपरनेत्रिनो

@Smarts इसका मतलब यह है कि अगर किसी भाषा का एक अलग कोडपेज है और उदाहरण के लिए '5'नियमित रूप से कोडपॉइंट पर कब्जा है 'A', तो आपको उपयोग करने की अनुमति नहीं है '5'
हाइपरन्यूट्रीनो

@KSmarts जिसका अर्थ है कि यदि आपके पास एक गैर-मानक कोडपेज है, तो ये अक्षर उस कोडपेज पर घूमते हैं। आप अभी भी अपने प्रोग्राम के भाग के रूप में उनके कोडपॉइंट का उपयोग कर सकते हैं।
स्टीफन

3

पाइके , 133 144 बाइट्स

? BXKKKKRKRKRK\CkJ00q}}}XEjTX}G_E\E\L\LkJjRT}}XRGREkJjR 00q}R? B_RE\ \wkJjRT}}XRGRE\R\L\DkJjRZ0q}}R? B_RER? JR? KREZjZ0q}AREkJjRT}}RG_RE00q}}RAA

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

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

? BXKKKKRKRKRK\CkJ - ".C" - A string that when evaled, gets the character at the point
00q}}}XEj - Construct 64 by doing `((0==0)*2*2*2)**2` and then eval, getting the "@" character and store it in `j`
TX}G_E - Get "h" using `@` by looking it up in the alphabet
\E\L\LkJ - "hELL"
jRT}}XRGREkJ - "hELLo"
jR 00q}R? B_RE  - ","
\ \wkJ - "hELLo, w"
jRT}}XRGRE\R\L\DkJ - "hELLo, woRLD"
jRZ0q}}R? B_RER? JR? KREZjZ0q}AREkJ - "hELLo, woRLD!"
jRT}}RG_RE00q}}RAA - "Hello, World!"

2

डीसी , 164 162 बाइट्स

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzS zzS?zzzzzzzzzzzzS$zzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzzzzzzzzzzzzzzzSwzzzzzzzzzzzzzzzPzzzzzzzzSLzPzPzzzzPL$PL PLwPzPzzzzPLLPAI*PL?P

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

बेहतर / अधिक दिलचस्प दृष्टिकोण होने की संभावना है। मैंने ASCII + 256 ट्रिक का उपयोग करने की कोशिश की dcहै, लेकिन यह अतिरिक्त वर्णों को भी आउटपुट करता है (भले ही वे नॉन-प्रिंटिंग हों), और एक बार जब मुझे 'ओ' मिल गया, तो आश्चर्यजनक रूप से प्राइम 111, मैं एक मुसीबत में भी भाग गया 111+ का मान (256 का गुणक) जो साफ-सुथरे तरीके से फैले। तो यहाँ एक बहुत सीधा है (यद्यपि संभव है, जहां घोल दिया गया है):

में dc, zएक कमांड है जो स्टैक पर स्टैक की गहराई को धक्का देता है। इसका मतलब है कि हम इसे वेतन वृद्धि के रूप में उपयोग कर सकते हैं। इस चुनौती के लिए मैं अपने अधिकांश ASCII मूल्यों को इसी तरह से बनाता हूं (जिनके साथ मुद्रित किया गया है P), जिसे मैं नामित स्टैक पर धक्का देता हूं Sऔर मुख्य स्टैक पर वापस पॉप करता हूंL

dcइनपुट मूलांक दशमलव (डिफ़ॉल्ट) होने पर भी आप हेक्स मानों AF का उपयोग करते हैं। सौभाग्य से, हमारा पहला अक्षर, 72, 12 का एक गुण है, इसलिए मैं एक बाइट या दो को 6 * 12 से गुणा करके और तुरंत प्रिंट करके ( zzzzzzzC*P) सहेजता हूं । मेरे 164-बाइट संस्करण ने 72 ('एच') प्राप्त करने के लिए शुरुआती गुणा का उपयोग किया, जो कि मामूली रूप से चतुर था, लेकिन पहले प्रयास से एक होल्डओवर और बाइट्स की बर्बादी थी। अब, मैं अंतरिक्ष को बढ़ाने और सहेजने से शुरू करता हूं, विस्मयादिबोधक बिंदु, और अल्पविराम, जो क्रम से बाहर हैं, और इसलिए अभी तक मुद्रित नहीं किया जा सकता है। इसके बाद, मैं 'H' पर आता हूं, जिसे मैं तुरंत 'W' में लाने से पहले प्रिंट करता हूं, जिसे मुझे बाद में सेव करना होगा।

मैं बस तब प्रिंट करता हूं जब मैं 'ई' से टकराता हूं, फिर मैं 'एल' तक बढ़ जाता हूं। मैं उनमें से दो को प्रिंट करता हूं और एक को बचाता हूं। जब मैं इसे 'ओ', मैं पहले सोचा था कि मैं बाद के लिए उन में से एक को बचाने के लिए होगा, लेकिन सब कुछ है की तरह इस बिंदु पर क्रम में। मैं 'o' प्रिंट करता हूं, पहले से मेरा अल्पविराम, स्थान और 'W' पुनर्प्राप्त करता हूं, और अब मैं 'o' पर वापस आता हूं। मैं इसे प्रिंट करता हूं, और कुछ को अधिकतम आवश्यक मूल्य तक बढ़ाता हूं, 'आर' (114), जिसे मैं लोड करने से पहले प्रिंट करता हूं और 'एल' को प्रिंट करता हूं, जिसे मैंने पहले ही टक दिया था।

लगभग हो गया! 'd' ASCII मान 100 है, जो आसानी से 10 * 10 को गुणा करके (इसे पहले लोड करने और अब लोड करने की तुलना में कम बाइट्स) द्वारा किया जाता है। हेक्स मान A10 है, जैसा कि हमारा इनपुट मूलांक है जिसे हम कमांड के साथ पुनः प्राप्त कर सकते हैं I। उन लोगों को गुणा करें, प्रिंट करें, और फिर पहले से हमारे विस्मयादिबोधक बिंदु को लोड और प्रिंट करें। नमस्ते दुनिया!

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