"हैलो, वर्ल्ड!" (हर दूसरे चरित्र, भाग 2)

Question

नमस्ते, विश्व के भाग 2 के एक प्रकार के रूप में ! (प्रत्येक अन्य वर्ण) , ऐसा प्रोग्राम लिखें, जिसमें ये तीनों प्रोग्राम "हेलो, वर्ल्ड!" प्रिंट करें: पूरे प्रोग्राम, आपके प्रोग्राम के पहले, तीसरे, 5 वें, आदि अक्षर, और दूसरे, चौथे, 6 ठें। आदि।

यदि आपका कार्यक्रम है:

abc
def

यह आउटपुट "हैलो, वर्ल्ड!" होना चाहिए, लेकिन ऐसा होना चाहिए

acdf

तथा

b
e

अंतर्निहित "हैलो, वर्ल्ड!" के साथ कोई समाधान नहीं।

Comments

सिर्फ "हैलो, वर्ल्ड!" से टेक्स्ट क्यों नहीं बदला कुछ और करने के लिए

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

मुझे लगता है कि खामियों से काफी हद तक बचा जाता है और "हैलो, वर्ल्ड!" विहित है।

— लियो तेनेबाम

IMO "हैलो, वर्ल्ड!" की तुलना में एक अलग स्ट्रिंग देखना अच्छा होगा एक बार थोड़ी देर में (वह सिर्फ मेरी राय है)

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

क्या व्हाट्सएप और न्यूलाइन्स को पात्रों के रूप में गिना जाता है?

— आधिकारिक

@ ConorO'Brien सुखद साइड इफेक्ट के साथ कि बहुत कम भाषाओं में हर दूसरे स्ट्रिंग के लिए बिल्ट-इन होगा।

— डेनिस

Answer 1

x86 मशीन कोड, 378 बाइट्स

PROG.COM उदाहरण के लिए MS-DOS एमुलेटर, DOSBox में डाउनलोड और चलाएं ।

B3 B4 B3 02 90 B3 B3 B4 02 B3 B4 B3 02 90 B3 B2
B3 48 90 B3 B3 B2 48 B3 B2 B3 48 90 B3 CD B3 21
90 B3 B3 CD 21 B3 CD B3 21 90 B3 B2 B3 65 90 B3
B3 B2 65 B3 B2 B3 65 90 B3 CD B3 21 90 B3 B3 CD
21 B3 CD B3 21 90 B3 B2 B3 6C 90 B3 B3 B2 6C B3
B2 B3 6C 90 B3 CD B3 21 90 B3 B3 CD 21 B3 CD B3
21 90 B3 CD B3 21 90 B3 B3 CD 21 B3 CD B3 21 90
B3 B2 B3 6F 90 B3 B3 B2 6F B3 B2 B3 6F 90 B3 CD
B3 21 90 B3 B3 CD 21 B3 CD B3 21 90 B3 B2 B3 2C
90 B3 B3 B2 2C B3 B2 B3 2C 90 B3 CD B3 21 90 B3
B3 CD 21 B3 CD B3 21 90 B3 B2 B3 20 90 B3 B3 B2
20 B3 B2 B3 20 90 B3 CD B3 21 90 B3 B3 CD 21 B3
CD B3 21 90 B3 B2 B3 77 90 B3 B3 B2 77 B3 B2 B3
77 90 B3 CD B3 21 90 B3 B3 CD 21 B3 CD B3 21 90
B3 B2 B3 6F 90 B3 B3 B2 6F B3 B2 B3 6F 90 B3 CD
B3 21 90 B3 B3 CD 21 B3 CD B3 21 90 B3 B2 B3 72
90 B3 B3 B2 72 B3 B2 B3 72 90 B3 CD B3 21 90 B3
B3 CD 21 B3 CD B3 21 90 B3 B2 B3 6C 90 B3 B3 B2
6C B3 B2 B3 6C 90 B3 CD B3 21 90 B3 B3 CD 21 B3
CD B3 21 90 B3 B2 B3 64 90 B3 B3 B2 64 B3 B2 B3
64 90 B3 CD B3 21 90 B3 B3 CD 21 B3 CD B3 21 90
B3 B2 B3 21 90 B3 B3 B2 21 B3 B2 B3 21 90 B3 CD
B3 21 90 B3 B3 CD 21 B3 CD B3 21 90 B3 CD B3 20
90 B3 B3 CD 20 B3 CD B3 20 90

इसके अलावा आप LEFT.COM और RIGHT.COM डाउनलोड कर सकते हैं

यह कैसे काम करता है और कैसे चलाना है

भाग एक का उत्तर देखें

जादू

यदि आप 0xAB ओपकोड कमांड को एक पैरामीटर 0xCD के साथ निष्पादित करना चाहते हैं , तो आप लिखते हैं

जनक

कोड चलाएँ, हेक्स प्राप्त करें। बाइनरी में कनवर्ट करें

cat prog.hex | xxd -r -p > PROG.COM

function byte2hex(byte){
	var ret=byte.toString(16).toUpperCase();
	return ret.length==1 ? "0"+ret : ret;
}

function str2hex(str){
	var ret = [];
	for(var i=0;i<str.length;i++){
		ret.push(byte2hex(str.charCodeAt(i)));
	}
	return ret;
}

function genCode(hexArr){
	var ret = [["B4","02"]];
	for(var i=0;i<hexArr.length;i++){
		if(hexArr[i]!=hexArr[i-1]){
			ret.push(["B2",hexArr[i]]);
		}
		ret.push(["CD","21"]);
	}
	ret.push(["CD","20"]);

	return ret;
}

function format(arr){
	var ret=[],tmp=[];
	for(var i=0;i<arr.length;i++){
		tmp.push(arr[i]);
		if(i%16==15 || i==arr.length-1){ret.push(tmp.join(" "));tmp=[];}
	}
	return ret.join("\n");
}

function magicCode(str,mode){
	var ret=[];
	var code=genCode(str2hex(str));

	for(var i=0;i<code.length;i++){
		var ab=code[i][0],cd=code[i][1],tmp;
		tmp=["B3",ab,"B3",cd,"90","B3","B3",ab,cd,"B3",ab,"B3",cd,"90"];
		for(var j=0;j<tmp.length;j++){
			if((mode&1 && j%2==0) || (mode&2 && j%2==1)){ret.push(tmp[j])}
		}
		
	}
	return ret;
}

const LEFT=1,RIGHT=2,ALL=3;

var str=prompt("string","Hello, world!");

var out = ["PROG.COM\n",format(magicCode(str,ALL)),"\n\nLEFT.COM\n",format(magicCode(str,LEFT)),"\n\nRIGHT.COM\n",format(magicCode(str,RIGHT))].join("\n");

document.write(out.replace(/\n/ig,"<br>"));

Answer 2

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

print=="partisn't";
"ran" >="partisn't" ;
print((""" "HHeelllloo,,  wwoorrlldd!! """[" ) #2">"1":: 3- 1] [ 1:-1 ]))

हर विषम चरित्र

pit=print;"a">"ats'";pit(" Hello, world! "[  2>1: -1  :1])

हर किरदार भी

rn="ats'"
rn =print 
rn("""Hello, world!""")#""":3 ][1- )

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

यह शायद बहुत कम हो सकता है, लेकिन मुझे खुशी है कि मैं पायथन में काम करने में कामयाब रहा। पहले भाग पर vroomfondel के उत्तर के समान ।

बोरिंग 93 बाइट का जवाब

""""""
print("Hello, world!")
""""""#
""""

pprriinntt((""HHeelllloo,,  wwoorrlldd!!""))
#"""

हर विषम चरित्र

"""pit"el,wrd"
"""
""
print("Hello, world!")#"

हर किरदार भी

"""
rn(Hlo ol!)"""#""
print("Hello, world!")
""

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

Answer 3

> <> , 45 बाइट्स

! """!!ddllrrooWW  oolllleeHH"!!"" >~o <> o <

या सिर्फ वर्ण:

 "!dlroW olleH"!">o<  

या सिर्फ विषम वर्ण:

!""!dlroW olleH!" ~ >o<

उन्हें ऑनलाइन प्रयास करें: मूल , evens , बाधाओं ।

मूल संस्करण !!ddllrrooWW oolllleeHHस्टैक के लिए " " धक्का देता है , फिर मछली बीच में उछलती है >~o <, जो एक पत्र को हटाता है, दो को प्रिंट करता है, दो को हटाता है, दो को हटाता है, दो को हटाता है। दो आधे प्रोग्राम काफी मानक स्ट्रिंग प्रिंटिंग प्रोग्राम हैं। मुश्किल हिस्सा तीनों कार्यक्रमों में सही तरीके से स्ट्रिंग मोड में संयोजन "और !टॉगल करना था ।

Answer 4

Befunge-98 , 43 बाइट्स

120 x""!!ddllrrooWW  ,,oolllleeHH""cckk,,@@

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

केवल विषम वाले:

10x"!dlroW ,olleH"ck,@

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

केवल यहां तक ​​कि:

2 "!dlroW ,olleH"ck,@

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

व्याख्या

पूरा कार्यक्रम:

120               Push 1, push 2, push 0.
x                 Pop 0 (y) and 2 (x) and set the instruction pointer's movement
                  delta to (x,y). That is, run the remainder of the code
                  by skipping every other cell.
"!dlroW ,olleH"   Push the code points of the output.
ck,               Print 13 characters from the top of the stack.
@                 Terminate the program.

विषम कार्यक्रम में, 2चला गया है, ताकि 10xवास्तव में कुछ भी नहीं करता है (यह डेल्टा सेट करता है (1,0)जो वैसे भी डिफ़ॉल्ट है)। कार्यक्रम का शेष भाग फिर वही है।

यहां तक ​​कि कार्यक्रम में, हम 2शुरुआत में ही धक्का देते हैं जिसे हम पूरी तरह से अनदेखा कर सकते हैं। कार्यक्रम का शेष पहले जैसा है।

Answer 5

गैम्प्लेक्स , 46 बाइट्स

//

EERRrrXXXX""HHeelllloo,,  WWoorrlldd!!""XX

यहाँ देखें।

दुभाषिया। आधुनिक संकलक में काम करने के लिए इसमें कुछ बदलावों की आवश्यकता हो सकती है।

Answer 6

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

PPrriinntt[[""HHeelllloo,,  WWoorrlldd!!""]]Print@"Hello, World!"

यह कुछ चेतावनियों, प्रिंटों Hello, World!और रिटर्न को फेंकता है Null PPrriinntt[["" HHeelllloo, Null, "" WWoorrlldd!!]]। जब एक प्रोग्राम (आरईपीएल में नहीं) के रूप में चलाया जाता है, तो रिटर्न वैल्यू प्रिंट नहीं की जाएगी।

सम वर्ण हटाने के बाद:

Print["Hello, World!"]Pit"el,Wrd"

यह प्रिंट करता है Hello, World!, और रिटर्न करता है "el,Wrd" Null Pit।

विषम वर्णों को निकालने के बाद:

Print["Hello, World!"]rn@Hlo ol!

यह प्रिंट करता है Hello, World!, और रिटर्न करता है Null ol! rn[Hlo]।

Answer 7

x86 मशीन कोड, 73 बाइट्स

Оввгений Новиков के समाधान से प्रेरित होकर , मैंने सोचा कि इसे कम चाल के साथ, यानी, केवल तीनों वेरिएंट के लिए अन्यथा "असंतुष्ट" कोड के लिए कूदना चाहिए। मैं अभी भी एक स्मार्ट संस्करण के साथ कोशिश कर रहा हूं जो lodsb; lodsbकेंद्रीय बिंदु के रूप में उपयोग करता है (इसलिए सभी वेरिएंट के लिए केवल एक स्ट्रिंग स्थिरांक की आवश्यकता है)

EB 14 00 00 8A 8A 17 16 01 01 B4 B4 09 09 CD CD
21 21 CD CD 20 20 8A 1f 01 B4 09 CD 21 CD 20 48
65 6c 6c 6f 2c 20 57 6f 72 6c 64 21 00 48 48 65
65 6c 6c 6c 6c 6f 6f 2c 2c 20 20 57 57 6f 6f 72
72 6c 6c 64 64 21 21 00 00

यदि मुझे अपने बचपन के दिनों से सही ढंग से याद है, तो COM के छोटे मॉडल के साथ शुरू होता है DS=CS=SS और कोड शुरुआत से लोड होता है CS:0100h। मुझे नहीं लगता कि यह गारंटी है कि कोड को एक शून्य मेमोरी ब्लॉक में लोड किया गया है (यदि यह गारंटी दी गई थी, तो मैं दो बाइट छोड़ सकता हूं)।

लंबे कोड का डिस्सैड होना चाहिए

  JMP *+14h
  ; 20 irrelevant bytes
  MOV DX,message
  MOV AH,09h
  INT 21h;  print string pointed to by DS:DX
  INT 20h;  exit program
message:
  DB "Hello, World!\0"
  DB "HHeelllloo,,  WWoorrlldd!!\0\0"

विषम कोड की गड़बड़ी

  JMP *+00h
  MOV DX,message
  MOV AH,09h
  INT 21h;  print string pointed to by DS:DX
  INT 20h;  exit program
  ; some irrelevant bytes
message:
  DB "Hello, World!\0"

यहां तक ​​कि कोड के डिस्सैस भी:

  ADC AL,00h
  MOV DX,message
  MOV AH,09h
  INT 21h;  print string pointed to by DS:DX
  INT 20h;  exit program
  ; some irrelevant bytes
message:
  DB "Hello, World!\0"

Comments

बहुत बढ़िया! DOSBox प्रोग्राम में काम नहीं कर रहा है। मुझे नहीं पता कि कॉम इस फाइल को शुरू में फ्रीज सिस्टम के साथ क्यों फाइल करता है।

— Julвгений Новиков

अगली बार अपने कोड का परीक्षण करें। 8A0116 में होना चाहिए BAबजाय, और तार से समाप्त कर दिया जाता $है, न कि शून्य।

— 19

Answer 8

रेटिना , 48 बाइट्स

G |`

HHeelllloo,,  WWoorrlldd!!
$_&

(.)\1t?
$1

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

अजीब स्थिति:

G|
Hello, World!
_
()1?$

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

यहां तक ​​कि स्थिति:

 `
Hello, World!$&
.\t
1

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

व्याख्या

पूरा कार्यक्रम:

G |`

यह कुछ भी नहीं करता है। |किसी मौजूदा कॉन्फ़िगरेशन विकल्प नहीं है। Gयह एक ग्रेप चरण में आता है, लेकिन वहाँ वास्तव में कुछ भी नहीं grepped किया जा रहा है और रेगुलर एक्सप्रेशन से, किसी भी खाली है तो यह कुछ भी नहीं है। इस चरण का उद्देश्य मुख्य "हैलो, वर्ल्ड!" के सामने दो लाइनफीड होना है। लाइन ताकि उनमें से एक हमेशा कमी से बचे। इसे grep स्टैग बनाने का कारण यह है कि हमें लाइनों की समता को ऑफसेट करने की आवश्यकता है, और grep चरणों को केवल एक ही लाइन की आवश्यकता होती है।

HHeelllloo,,  WWoorrlldd!!

यह प्रत्येक वर्ण को दोगुना करने के साथ आवश्यक आउटपुट में रिक्त (खाली) काम कर रहा है।

$_&

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

(.)\1t?
$1

अंत में, हम को प्रतिस्थापित करके डुप्लिकेट वर्ण निकालने (.)\1के साथ$1 । का t?उपयोग कभी नहीं किया जाता है, लेकिन फिर से कम किए गए संस्करणों में आवश्यक होगा।

अजीब कार्यक्रम:

G|
Hello, World!

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

_
()1?$

इसके साथ अंडरस्कोर बदलता है ()1?$ , लेकिन स्ट्रिंग में अंडरस्कोर नहीं हैं, इसलिए यह कुछ भी नहीं करता है।

यहां तक ​​कि कार्यक्रम:

 `
Hello, World!$&

`सिर्फ एक खाली विन्यास स्ट्रिंग को दर्शाता है, तो हम फिर से उत्पादन के साथ काम कर स्ट्रिंग को बदलने के लिए खाली regex का उपयोग। इस बार हम भी डालें$& लेकिन यह मैच ही है, जो खाली है, ज़ाहिर है, इसलिए यह कुछ भी नहीं करता है।

.\t
1

यह किसी भी वर्ण को टैब के बाद बदल देगा 1, लेकिन हमारे पास कोई टैब नहीं है, इसलिए यह भी एक सेशन नहीं है।

Answer 9

लुआ , 106 बाइट्स

----[[[[
print("Hello, World!")
--[[
---- ] ]
---- ] ]
pprriinntt((""HHeelllloo,,  WWoorrlldd!!""))
----]]

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

वैकल्पिक 1:

--[[
rn(Hlo ol!)-[
--]]--  
print("Hello, World!")--]

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

वैकल्पिक # 2:

--[[pit"el,Wrd"
-[--  
--]]print("Hello, World!")
--]

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

अल्टरनेटर स्क्रिप्ट: इसे ऑनलाइन आज़माएं!

Answer 10

CJam , 44 बाइट्स

{{HHeelllloo,,  WWoorrlldd!!}}ss{{}}ss-X)%L-

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

Answer 11

PHP, 70 बाइट्स

"";echo'Hello, World!'.""//pprriinntt''HHeelllloo,,  WWoorrlldd!!''
;;

अजीब चरित्र:

";coHlo ol!."/print'Hello, World!';

यहां तक ​​कि वर्ण:

"eh'el,Wrd'"/print'Hello, World!'
;

Answer 12

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

{---- }

mmaaiinn==ppuuttSSttrr""HHeelllloo,,  WWoorrlldd!!""----}main=putStr"Hello, World!"

इसे ऑनलाइन आज़माएं! ऐसा लगता है कि टिप्पणी का दुरुपयोग वाक्य विन्यास को संभालने के लिए बहुत अधिक है। {- ... -}इनलाइन या मल्टी-लाइन टिप्पणी है, जबकि-- एक लाइन टिप्पणी शुरू होती है।

अजीब चरित्र:

{--}
main=putStr"Hello, World!"--mi=uSrHlo ol!

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

यहां तक ​​कि वर्ण:

-- 
main=putStr"Hello, World!"--}anptt"el,Wrd"

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

Answer 13

Zsh , 54 बाइट्स

<<<Hello\ world!||eecchhoo  HHeelllloo\\  wwoorrlldd!!

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

मुख्य कार्यक्रम पहले कथन को सफलतापूर्वक निष्पादित करता है, इसलिए बूलियन ||को नजरअंदाज करने के बाद का बयान ।

अजीब के लिए / भी, <<<Hello\ world!या तो एक समाप्त नहीं की गई हो जाता है <<heredocया एक <filestdin पर प्रदान की है। किसी भी तरह से, ||बन जाता है |, और इसलिए जो कुछ भी पहले कमांड द्वारा आउटपुट किया जाता है उसे पाइप किया जाता है और उसके द्वारा अनदेखा किया जाता है echo।

Answer 14

लोगो , 71 बाइट्स

;;\\
pr[Hello, World!]er "|

pprr[[HHeelllloo,,  WWoorrlldd!!]]
;;\\
|

(कार्यक्रम की एक नई रूपरेखा है)

दो हटाए गए संस्करण:

;\p[el,Wrd]r"
pr[Hello, World!]
;\|

तथा

;\
rHlo ol!e |
pr[Hello, World!];\

(कार्यक्रम की एक नई रूपरेखा है)

एक स्पष्टीकरण के लिए कि क्या करें prऔर erक्या करें, इस पोस्ट को देखें । इस मामले में, erएक शब्द निर्धारित प्रक्रिया नाम के साथ फ़ीड है।

\लोगो में एस्केप वर्ण, जो टिप्पणी की समाप्ति के बाद न्यू लाइन बच जाएंगे, इसलिए दूसरी पंक्ति (बनाना है rHlo ol!e |दूसरे हटा कार्यक्रम एक टिप्पणी की)।

Answer 15

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

//**
alert`Hello, World`//**//aalleerrtt``HHeelllloo,,  WWoorrlldd``

विषम वर्ण:

/*aetHlo ol`/*/alert`Hello, World`

यहां तक ​​कि वर्ण:

/*
lr`el,Wrd/*/alert`Hello, World`

दूसरे पर मेरे उत्तर का संशोधित संस्करण।

Comments

आपको शुरुआत में स्थान की आवश्यकता क्यों है?

— कैलक्यूलेटरफ्लेन

जब आप 1, 3, आदि वर्ण लेते हैं, तो यह वाक्यात्मक रूप से मान्य नहीं लगता है। इसके अलावा, यह एक lमें याद आ रही है HHeelllloo।

— अरनुलद

@ कैलक्यूलेटरफल, @ अरनौल्ड तय

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

Answer 16

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

60 बाइट्स कोड + 1 के लिए -p।

$ _ =$ _ =q";HHeelllloo,,  WWoorrlldd!!";;;q##;s/;|.\K.//g##

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

हर अजीब बाइट

  $_="Hello, World!";q#s;.K/g#

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

हर बाइट

$_=  q;Hello, World!;;#;/|\./#

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

Answer 17

बॉटजाइन , 180 178 बाइट्स

इस सवाल के मेरे जवाब के आधार पर ।

 vv 
 v < 
 eHH 
 eee 
 ell 
 ell 
 eoo 
 e,, 
 e   
 eWW 
 eoo 
 err 
 ell 
 edd 
 e!! 

>>P          e     e     e     e     e     e     e     e     e     e     e     e     e P

विषम वर्ण (अंतिम पंक्ति में कई अनुगामी रिक्त स्थान पर ध्यान दें):

 v
v<
eH
ee
el
el
eo
e,
e 
eW
eo
er
el
ed
e!
>P                                          

यहां तक ​​कि वर्ण:

v     H  e  l  l  o  ,     W  o  r  l  d  ! 
>     e  e  e  e  e  e  e  e  e  e  e  e  eP  

Answer 18

रूनिक एनकाउंटर , 52 बाइट्स

 L @""H!edlllroo,W  W,oorlllde!H"" ~@"!dlroW ,olleH"

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

रूनिक विकिरण से निपटने में आमतौर पर बहुत अच्छा नहीं होता है क्योंकि यादृच्छिक पर हटाए जाने वाले फ्लो कंट्रोल कैरेक्टर ट्रेसिंग निष्पादन को बहुत बड़ा दर्द बनाते हैं, लेकिन हर दूसरे किरदार की तरह प्रेडिक्टेबल रेडिएशन? आसान है, हम सिर्फ दो कार्यक्रमों को एक दूसरे के साथ उलटते हैं और एक दूसरे से जुड़े हुए हैं, फिर आधार निष्पादन और नियंत्रण के लिए एक तीसरी प्रति से निपटते हैं, जिसे किसी एक चरित्र के साथ निष्पादित किया जाता है। प्रोग्राम 2 में, तीसरी कॉपी कचरा है जिसे कभी नहीं देखा जाता है, और प्रोग्राम 3 में यह उद्धरणों को बरकरार रखता है, जिससे इसे बिना प्रिंट किए पॉपअप किया जा सकता है।

कार्यक्रम 1 केवल इस भाग को निष्पादित करता है:

 L                                  @"!dlroW ,olleH"

प्रोग्राम 2 केवल इस भाग को निष्पादित करता है:

    " H e l l o ,   W o r l d ! "   @               

ऐशे ही:

  "Hello, World!" @!lo olH

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

प्रोग्राम 3 केवल इस भाग को निष्पादित करता है:

 L @ " ! d l r o W   , o l l e H " ~ " d r W , l e "

ऐशे ही:

L@"!dlroW ,olleH"~"drW,le"

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

"drW,le"भाग निष्पादित किया जाता है, लेकिन~ तुरंत ढेर बंद यह दिखाई दे, वांछित आउटपुट संरक्षण।

संभवतः यह प्रतीत होता है कि> <> जवाब के रूपांतरण के परिणामस्वरूप 45 बाइट्स का वजन कम कार्यक्रम होगा:

! ```!!ddllrrooWW  oolllleeHH`!!`` R~$ LR $ L

हालांकि, रूनिक की एक सीमा है कि> <> में नहीं है: 10 + आईपी के मान का अधिकतम स्टैक आकार (जो शुरू में है)। और !!ddllrrooWW oolllleeHHइसमें 24 अक्षर होते हैं, जिससे IP को तब तक मैना से खून बहता है जब तक कि यह Rकमांड निष्पादित करने से ठीक पहले समाप्त हो जाता है , जिसके परिणामस्वरूप बेस प्रोग्राम के लिए कोई आउटपुट नहीं है।

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