नमस्ते दुनिया! (हर दूसरा किरदार)

Question

एक प्रोग्राम लिखें जो प्रिंट करता है "हैलो, वर्ल्ड!"। लेकिन यह भी, यदि आप अपने कार्यक्रम के केवल पहले, तीसरे, पांचवें, आदि पात्रों को लेते हैं, तो परिणामी कार्यक्रम को अभी भी "हैलो, वर्ल्ड!" प्रिंट होना चाहिए।

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

abc
def

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

acdf

2 से कम अक्षरों वाला कोई समाधान नहीं।

Comments

क्या आउटपुट के आसपास व्हाट्सएप हो सकता है?

— वृमफोंडेल

अद्भुत पहली पोस्ट!

— अड्म

"HHeelllloo" के साथ सभी उत्तरों को देखकर मुझे व्हेल के बोलने की याद आई।

— ब्रायन मिंटन

"नमस्ते, विश्व!" से बचने के लिए प्रो टिप इस तरह की चुनौतियों में अंतर्निहित: "ग्रीटिंग्स, अर्थलिंग्स" जैसी समान जटिलता की थोड़ी अलग स्ट्रिंग का उपयोग करें!

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

"2 से कम वर्णों वाला कोई समाधान नहीं।" गजब का।

— रॉबर्ट ग्रांट

Answer 1

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

rant="partisn't"
print(("HHeelllloo,,  WWoorrlldd!!"""[::2]))

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

इस तथ्य का दुरुपयोग कि printपायथन 3 में एक समारोह है :)

पीपीसीजी पर आपको यहां सबसे कम पक्षपातपूर्ण समाधान मिलेगा।

हो जाता है

rn=print
rn("Hello, World!"[:])

Comments

ये सुन्दर है।

— संगीतकार ५२३

@ musicman523 लेकिन, उस मामले में एकल-उद्धरण वाले पाठ को न देखें।

— अधिकारिक

@officialaimm हाँ, मुझे लगता है कि यह करता है

— संगीतकार ५२३

@ yamboy1 हर दूसरे अक्षर को हटाने की कोशिश करें

— vroomfondel

मुझे नहीं पता था कि [:]वास्तव में काम किया: ओ नीस!

— हाइपरएन्यूट्रीनो

Answer 2

कार्डिनल , 29 बाइट्स

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

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

हर दूसरे चरित्र को हटाने से सभी लाइनफीड्स दूर हो जाते हैं, जिसके परिणाम अभी भी हैं Hello, World!:

%"Hello, World!

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

इसका कारण यह है कि %चार निर्देशांक बनाता है, जो प्रत्येक चार कार्डिनल दिशाओं में घूम रहा है। स्रोत कोड को छोड़ने वाले आईपी को बस हटा दिया जाता है। तो पहले मामले में, केवल दक्षिण-जा रही आईपी बनी हुई है और दूसरे मामले में, केवल पूर्व-चल रही आईपी बनी हुई है, अन्य सभी बस छोड़ दिए गए हैं। किसी भी मामले में, निष्पादित कार्यक्रम तब होता है "Hello, World!। "स्ट्रिंग मोड में टॉगल जहां प्रत्येक कोशिका बस STDOUT करने के लिए मुद्रित है। हमें स्ट्रिंग को समाप्त करने की आवश्यकता नहीं है, क्योंकि स्रोत कोड छोड़ने से अभी भी कार्यक्रम समाप्त हो जाता है।

ध्यान दें कि एक ही विचार Beeswax में काम करता है , के *बजाय %और `इसके बजाय "(यह इसलिए है क्योंकि Beeswax काफी हद तक कार्डिनल से प्रेरित था लेकिन एक हेक्सागोनल ग्रिड का उपयोग करता है)।

इसे ऑनलाइन आज़माएं! (वर्टिकल) | | इसे ऑनलाइन आज़माएं! (क्षैतिज)

Answer 3

सी, 125 बाइट्स

xpxuxtxs( ) { }xuxs ( ) { } main( ) {puts ( "Hello, World!" ) ; } mxaxixn ( ) {xpxuxtxs ( " H e l l o ,   W o r l d ! " ) ; }

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

हटाए गए वर्णों के साथ भी:

xxxx(){}us(){}mi(){us("el,Wrd");}main(){puts("Hello, World!");}

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

Answer 4

दरअसल , 2 बाइट्स

HH

स्पष्टीकरण:

H, जैसा कि आप उम्मीद कर सकते हैं, Hello, World!स्टैक को धक्का देता है।

मुख्य कार्यक्रम ( HH) पहले का सामना करेगा Hऔर Hello, World!स्टैक को धक्का देगा । दूसरे पर H, हालांकि, यह दो तर्कों का उपयोग करने की कोशिश करेगा (जैसा कि स्टैक को पुश करने के लिए खाली होने की आवश्यकता है Hello, World!) और असफल। हालांकि, इस त्रुटि को नजरअंदाज कर दिया Hello, World!जाएगा और फिर इसे छापा जाएगा।

दूसरा कार्यक्रम ( H) Hello, World!एक बार धक्का देगा , और यह प्रिंटिकली प्रिंट होगा।

यह Fatalize के 2-बाइट उत्तर के समान है, लेकिन यह वास्तव में "धोखा" नहीं है।

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

Comments

अच्छा समाधान है, लेकिन मुझे लगता है कि इसकी गिनती नहीं होनी चाहिए क्योंकि यह एक-चरित्र समाधान की तरह बहुत अधिक है।

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

@LeoTenenbaum क्यों नहीं? यह पूरी तरह से ठीक नियमों के अनुरूप है।

— ओकेक्स

जो आप समझाते हैं वह मामला नहीं है, Hकेवल Hello, World!एक खाली स्टैक पर जोर देगा , और यदि स्टैक खाली नहीं है, तो यह 2 तर्क की उम्मीद करेगा, इसलिए एक त्रुटि होगी, और त्रुटियों को अनदेखा किया जाएगा। और कोई वास्तव में केवल शीर्ष तत्व को नहीं छापता है।

— आउटगोल्फ

@EriktheOutgolfer उफ़। ठीक कर देंगे।

— ओकेक्स

यही कारण है कि वास्तव में मेरी पसंदीदा गोल्फ भाषा है। यह बेवकूफ के सही स्तर पर है।

— RShields

Answer 5

लूआ , 89 बाइट्स

--- [ [
print("Hello, World!")
--[[ ] ]
pCrAiLnCtU(L"AHTeOlRlFoE,L IWNoEr:lDd !:"D)
---]]

इसे ऑनलाइन आज़माएं! सिंटैक्स हाइलाइटिंग शो के रूप में, यह बड़े पैमाने पर टिप्पणी का दुरुपयोग है।

वैकल्पिक:

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

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

और सुविधा के लिए, एक प्रोग्राम को हर दूसरे चरित्र रूप में बदलने के लिए एक कार्यक्रम: इसे ऑनलाइन आज़माएं!

Comments

मैं यह पसंद है! लुआ का टिप्पणी प्रारूप टी-एसक्यूएल के समान लगता है, मैं कोशिश कर रहा हूं और उस भाषा के लिए काम करूंगा।

— ब्रैड

इस तरह की ट्रिक में किसी भी भाषा के लिए ब्लॉक कमेंट्स और लाइन कमेंट्स (C, JS, etc) दोनों के लिए काम करना चाहिए

— CalculatorFeline

CALCULATORFELINE: D: D

— राईकिंग

HHeelllloo WWoorrlldd!!यह थोड़े उबाऊ है: पी

— कैलकुलेटरफनलीन

Answer 6

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

HHeelllloo,,  WWoorrlldd!!


(.).x?
$1

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

हर दूसरे चरित्र देता है:

Hello, World!
()x
1

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

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

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

Answer 7

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

H→e→l→l→o→,→ →W→o→r→l→d→!

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

यदि आप सम वर्णों को हटाते हैं, तो आप केवल उस तीर कमान को हटाते हैं जो अगले पाठ की दिशा को इंगित करता है, और जो निम्न कोड छोड़ता है:

Hello, World!

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

वह भी ग्रीटिंग को प्रिंट करता है।

Answer 8

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

{--}main=putStr"Hello, World!"--} m a i n = p u t S t r " H e l l o ,   W o r l d ! "

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

हटाया गया हर दूसरा वर्ण:

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

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

यह हास्केल में दो टिप्पणी प्रारूपों का फायदा उठाता है: {- -}इन-लाइन या मल्टी-लाइन टिप्पणियों के लिए और --बाकी लाइन पर टिप्पणी करने के लिए।

Answer 9

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

/**/alert`Hello, World`// * / a l e r t ` H e l l o ,   W o r l d `

हर दूसरा पत्र निकाला गया:

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

लाइकोनी के हास्केल जवाब की तरह, यह टिप्पणियों का शोषण करता है।

Comments

अच्छा जवाब, +1! में अपने जवाब के एक बंदरगाह बनाने के द्वारा 2 बाइट्स सहेजा मेरी जावा 8 जवाब , और एक अतिरिक्त बाइट जब मैं बदल // * /करने के लिए //**/(जो दुर्भाग्य की वजह से अपने मामले में संभव नहीं है /**/alert`Hello, World` बाइट्स की एक अजीब राशि जा रहा है, के बजाय यहां तक कि मेरे मामले में की तरह ।

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

Answer 10

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

Ḥ~wḤ

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

व्याख्या

~wइसके दाएँ चर को लिखता है STDOUT, और इसके बाएँ तर्क को अनदेखा करता है। Ḥहै "Hello, World!", इसलिए यह प्रिंट Hello, World!।

यदि हम केवल पहले और तीसरे चरण को लेते हैं, तो हम प्राप्त करते हैं Ḥw। उस मामले में यह wअपने बाएं चर को लिखता है और इसके दाहिने चर को अनदेखा करता है, इसलिए यह प्रिंट भी करता है Hello, World!।

2 बाइट्स

ḤḤ

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

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

Comments

मुझे नहीं लगता कि 2 बाइट का जवाब 'तकनीकी रूप से' मान्य है, क्योंकि चुनौती राज्यों ने छापी है ।

— ओकेक्स

@ ऑक्स प्रिंट, कागज के एक टुकड़े के रूप में?

— Theonlygusti

@theonlygusti इसका मतलब है कि STDOUT में प्रिंट करें।

— ओकेक्स

@Theonlygusti Sigh ... जो कि डिफ़ॉल्ट रूप से प्रिंट से है।

— ओकेक्स

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

— Theonlygusti

Answer 11

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

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

main= putStr"Hello, World!";;
putSt   x ="p u t S t r  \" H e l l o ,   W o r l d !\"";
mmaaiin = main

और हटाए गए हर दूसरे चरित्र के साथ:

mi=ptt"el,Wrd";ptt x=putStr "Hello, World!";main=mi

Comments

आप के बीच रिक्त स्थान को हटाने के द्वारा 2 बाइट्स से दूर ले सकते हैं p u t S t rऔर \"।

— श्रीओटीचिलिज्म ओ'जैसिक

Answer 12

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

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

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

MINI.COM डाउनलोड को हटाने के बाद

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

कैसे चलाना है?

Ubuntu / Debian के लिए DOSBox स्थापित करें

sudo apt install dosbox

चलाओ

dosbox

DOSBOX में

mount c /home/user/path/to/your/directory
c:
PROG.COM
MINI.COM

यह कैसे काम करता है?

मशीन संचालन कोड विधानसभा भाषा निर्देशों का प्रतिनिधित्व करते हैं ।

MS-DOS में char प्रिंट करने के लिए आप रजिस्टर सेट करेंगे और इंटरप्ट करेंगे। एएच रजिस्टर 0x02 होगा, डीएल रजिस्टर में आपका चार्ट होता है। इंटरप्ट वेक्टर 0x21 है।

mov ah,0x2  ;AH register to 0x2 (B4 02)
mov dl,0x48 ;DL register to "H" (B2 48)
int 0x21    ;0x21 interrupt     (CD 21)

MS-DOS COM फ़ाइल छोटे मॉडल का अच्छा चयन है, क्योंकि इसमें कोई हेडर नहीं है । यह 64K तक सीमित है, लेकिन हमारे मामले में यह मायने नहीं रखता है।

प्रोग्राम के उपयोग को रोकने के लिए 0x20 इंटरप्ट

int 0x20    ;0x20 interrupt     (CD 20)

जादू

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

AB CD

में PROG.COM

90 B3 AB AB CD 90
nop         ; No operation (90)
mov bl,0xb4 ; BL register to AB (B3 AB)
AB CD command (AB CD)
nop         ; No operation (90)

में MINI.COM

90 AB CD
nop         ; No operation (90)
AB CD command (AB CD)

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

जनक

हेक्स बाइनरी के साथ हेक्स के साथ टेक्स्ट फाइल को कन्वर्ट करें

cat hex_file | xxd -r -p > exec.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 magicCode(str){
	var ret=[""];
	var code=genCode(str2hex(str));

	for(var i=0;i<code.length;i++){
		ret.push("90 B3 "+code[i][0]+" "+code[i][0]+" "+code[i][1]+" 90");
		if(i%4==3){ret.push("\n");}
	}
	return ret.join(" ");
}

function magicCodeMinified(str){
	var ret=[""];
	var code=genCode(str2hex(str));

	for(var i=0;i<code.length;i++){
		ret.push("90 "+code[i][0]+" "+code[i][1]);
		if(i%8==7){ret.push("\n");}
	}
	return ret.join(" ");
}

var str=prompt("string","Hello, world!");
var out="PROG.COM\n" + magicCode(str)+"\n\nMINI.COM\n"+magicCodeMinified(str);

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

Comments

-52 बाइट्स के लिए सभी `90 90` निकालें।

— निदेज्ज्कोब

इसके अलावा, बहुत अंत में एनओपी कभी नहीं पहुंचेगा।

— 20

Answer 13

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

p% 2"HHeelllloo,,  WWoorrlldd!!

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

हो जाता है

p "Hello, World!

एक त्रुटि को इंगित करने और एक बाइट को हटाने के लिए @CalculatorFeline को धन्यवाद।

Comments

वर्ण पहले से शुरू होते थे, दूसरे से नहीं। आप अग्रणी स्थान छोड़ सकते हैं।

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

आह, धन्यवाद @ कलकटरफलाइन। मैंने कल्पना में "टेक" को "निकालें" के रूप में पढ़ा।

— वूमफोंडेल

Answer 14

वी , 32 बाइट्स

i;H;e;l;l;o;,; ;w;o;r;l;d;!;<esc>;Ó;

ध्यान दें कि <esc>एक एकल वर्ण है, उदाहरण के लिए0x1b

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

हर दूसरे किरदार को हटा देना:

iHello, world!<esc>Ó

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

Answer 15

05AB1E , 29 बाइट्स

”™ ,ï‚‚ï ! ”# ¦2 ä ø¨øJð ý

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

व्याख्या

”™ ,ï‚‚ï ! ”                # push the string "Weekly Hello , Changed World ! "
               #               # split on spaces
                               # RESULT: ['Weekly','Hello',',','Changed','World','!','']
                ¦              # remove the first element (Weekly)
                 2ä            # split in 2 parts
                               # RESULT: [['Hello', ',', 'Changed'], ['World', '!', '']]
                   ø           # zip
                               # RESULT: [['Hello', 'World'], [',', '!'], ['Changed', '']]
                    ¨          # remove the last element
                     ø         # zip
                               # RESULT: [['Hello', ','], ['World', '!']]
                      J        # join each inner list
                       ðý      # join on space

हर दूसरे किरदार को हटाने के बाद हमें कोड के साथ छोड़ दिया जाता है

”Ÿ™,‚ï!” 2äøøðý

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

व्याख्या

”Ÿ™,‚ï!”       # push the string "Hello, World!"
        2ä     # split in 2 parts
               # RESULT: ['Hello, ', 'World!']
          ø    # zip, as the string has an odd length the space is lost
               # RESULT: ['HW', 'eo', 'lr', 'll', 'od', ',!']
           ø   # zip again
               # RESULT: ['Hello,', 'World!']
            ðý # join on space

Answer 16

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

P0r0i0n0t0@0"0H0e0l0l0o0,0 0W0o0r0l0d0!0"Print@"Hello, World!"

यह लौटता है "0H0e0l0l0o0,0 0W0o0r0l0d0!0" Null P0r0i0n0t0[0], और Hello, World!एक साइड इफेक्ट के रूप में प्रिंट करता है। जब एक प्रोग्राम (आरईपीएल में नहीं) के रूप में चलाया जाता है, तो रिटर्न वैल्यू प्रिंट नहीं की जाएगी।

हर दूसरे चरित्र को हटाने के बाद:

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

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

Answer 17

जेली , 26 25 बाइट्स

““3ḅaė;œ»ḷ“ 3 ḅ a ė ; œ »

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

हर दूसरे वर्ण को हटाने के बाद, हम निम्नलिखित कोड के साथ छोड़ देते हैं।

“3a;»“3ḅaė;œ»

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

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

““3ḅaė;œ»ḷ“ 3 ḅ a ė ; œ »  Main link.

““3ḅaė;œ»                  Index into Jelly's dictionary to yield
                           ["", "Hello, World!"]. 
          “ 3 ḅ a ė ; œ »  Index into Jelly's dictionary to yield.
                          " FullERebitingBEfluffiest adoptable".
         ḷ                 Take the left result.

“3a;»“3ḅaė;œ»  Main link.

“3a;»          Index into Jelly's dicrionary to yield " N-".
               Set the argument and the return value to the result.
     “3ḅaė;œ»  Index into Jelly's dicrionary to yield "Hello, World!".
               Set the return value to the result.

Answer 18

मूल रूप से v2.1 , 222 बाइट्स

+0503 @@6 :22 //1 +050501 @@6 :55 +0502 @@6@6 :33 //1 +050502 @@6 :55 +03 //1 +04 @@6 :55 //1 +03 @@6 :55 +01 //1 +0504 @@6 :33 //1 +050502 @@6 :55 +01 //1 +050502 @@6 :55 +0502 @@6 :11 //1 +050501 @@6 :55 +01 //1 +03 @@6

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

हर दूसरे पत्र:

+53@6:2/1+551@6:5+52@66:3/1+552@6:5+3/1+4@6:5/1+3@6:5+1/1+54@6:3/1+552@6:5+1/1+552@6:5+52@6:1/1+551@6:5+1/1+3@6

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

Answer 19

CJam , 32 बाइट्स

"HHeelllloo,,  WWoorrlldd!! "2 %

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

हर दूसरे चरित्र देता है:

"Hello, World!" 

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

Comments

वैकल्पिक संस्करण पर अनुगामी स्थान पर ध्यान दें।

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

Answer 20

मदद, WarDoq! , 2 बाइट्स

Hi

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

Hप्रिंट Hello, World!, iएक सेशन नहीं है।

_{मदद, WarDoq! दो नंबर जोड़ सकते हैं और primes के लिए परीक्षण कर सकते हैं, इसलिए इसे इस मेटा पोस्ट के अनुसार एक मान्य प्रोग्रामिंग भाषा माना जाता है ।}

Comments

इसे क्यों अस्वीकृत किया गया?

— ऊरीएल

एनओपी और बड़े पैमाने पर रिक्त स्थान भावना के खिलाफ हैं।

— RShields

+1 के कारण परिणाम पर स्रोत कोड फिर से बल देने वाले संदेश पर जोर देता है।

— TOOGAM

Answer 21

/// , 25 बाइट्स

H\e\l\l\o\,\ \W\o\r\l\d\!

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

हटाए गए हर दूसरे चरित्र के साथ:

Hello, World!

Answer 22

PHP, 53 बाइट्स

#
echo date(
$e_c_h_o='\H\e\l\l\o\,\ \W\o\r\l\d\!
');

हटाए गए हर दूसरे चरित्र के साथ:

#eh ae
echo'Hello, World!';

Answer 23

ऑक्टेव, 49 45 बाइट्स

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

'HHeelllloo,,  WWoorrlldd!! ' (1:2 : 3 ^ 3)''

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

और कम एक:

'Hello, World!'(:    )'

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

स्पष्टीकरण:

प्रारंभिक कोड में स्ट्रिंग में अक्षर डुप्लिकेट हैं, ताकि जब हम Hello, World!हर सेकंड हटाए जाएं तो हम साथ रहें। कोष्ठक और एपोस्ट्रोफ को बनाए रखने के लिए कुछ स्थान जोड़े जाते हैं।

अनुक्रमण वास्तव में है 1:2:end। 27 वर्ण हैं, और हम उपयोग नहीं कर सकते हैं endया 27चूंकि हमें एक चरित्र को निकालना चाहिए, इसलिए हम 3 ^ 3इसके बजाय जाते हैं। जब हम हर तीसरे वर्ण को हटाते हैं, तो अनुक्रमण (:)(और कुछ अतिरिक्त स्थान) बन जाता है ।

(:)का अर्थ है "समतल और एक ऊर्ध्वाधर वेक्टर में बदल" । इसलिए, हमें इसका उपयोग करते हुए, इसे स्थानांतरित करना होगा '। हमें मूल कोड में स्ट्रिंग को स्थानांतरित करने की आवश्यकता नहीं है, लेकिन डबल ट्रांस्पोज़िंग काम करता है, इसलिए पहली स्ट्रिंग का उपयोग करके दो बार ट्रांसपोज़ किया जाता है '', और दूसरा केवल एक बार ट्रांसपोज़ किया जाता है।

Answer 24

APL (Dyalog) , 35 34 बाइट्स

-1 मार्टिन एंडर को धन्यवाद।

'0H0e0l0l0o0,0 0W0o0r0l0d0!0'~ ⍕ 0

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

'0H0e0l0l0o0,0 0W0o0r0l0d0!0' हटाने योग्य भराव पात्रों के रूप में शून्य के साथ संदेश

~ के सिवाय

⍕ स्वरूपित (कठोर)

0 संख्या शून्य

केवल विषम वर्णों को छोड़कर, यह बन जाता है 'Hello, World!' ।

Answer 25

टी-एसक्यूएल, 75 बाइट्स

---
PRINT 'Hello, World!'
/*
-P-R-I-N-T-'-H-e-l-l-o-,- -W-o-r-l-d-!-'
---*/

कैलक्यूलेटरFeline के LUA संस्करण से प्रेरित सिंगल- और मल्टी-लाइन टिप्पणी का दुरुपयोग ।

सभी समान संख्या वाले वर्णों को हटाने के बाद, जिनमें से कुछ पंक्ति विराम हैं:

--PIT'el,Wrd'/
PRINT'Hello, World!'--/

Answer 26

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

a ='a0l0e0r0t0`0H0e0l0l0o0,0 0W0o0r0l0d0!0`0/0/';eval(a.replace(/0/g,''))

aसामग्री के साथ एक स्ट्रिंग का निर्माण करता है a0l0e0r0t0`0H0e0l0l0o0,0 0W0o0r0l0d0!0`0/0/, फिर सभी 0को देने के लिए निकालता है alert`Hello, World!`//, जो कि eval'डी' है।

कार्यक्रम के हर दूसरे चरित्र को देते हुए

a=alert`Hello, World!`//;vlarpae//,')

जो Hello, Worldटेम्पलेट स्ट्रिंग सिंटैक्स का उपयोग करते हुए अलर्ट करता है जैसे कि पूर्ण कार्यक्रम में क्या स्पष्ट था, फिर कॉल के परिणाम को संग्रहीत करता है aऔर इसमें व्यावहारिक टिप्पणी शामिल है //;vlarpae//,')।

Answer 27

> <> , 47 बाइट्स

मूल:

| v~" H e l l o ,   W o r l d ! "

~o<< ;!!!? l

हटाए गए हर दूसरे चरित्र के साथ:

|v"Hello, World!"
o<;!?l

उन्हें ऑनलाइन आज़माएं: मूल , संशोधित

मूल कार्यक्रम "हैलो, वर्ल्ड!" के पात्रों को आगे बढ़ाता है। स्टैक (रिवर्स ऑर्डर में) को रिक्त स्थान के साथ इंटरसेप्टर किया जाता है, फिर वैकल्पिक रूप से एक चरित्र को प्रिंट करता है और स्टैक की लंबाई शून्य होने तक एक हटा देता है। दूसरा प्रोग्राम वही करता है, जिसे हटाए जाने के निर्देशों ~को छोड़कर ।

यदि आप किसी त्रुटि के साथ रुकने का मन नहीं बनाते हैं, तो हम मार्टिन एंडर की कार्डिनल पुस्तक से एक पत्ता निकाल सकते हैं : संशोधित कोड है

\"!dlroW ,olleH"!#o#

और मूल एक ही है, लेकिन सभी पात्रों के बीच 39 बाइट्स के लिए डाला गया न्यूलाइन है। उन्हें ऑनलाइन आज़माएं: मूल , संशोधित ।

Answer 28

,,,, 34 बाइट्स

 2"Hteoltlaol,l yWhourmladn!! "⟛

सम संख्या वाले वर्णों को हटाने पर ...

 "Hello, World!"

व्याख्या

सभी पात्रों के साथ:

 2"..."⟛

               no-op
 2             push 2 to the stack
  "..."        push "Hteoltlaol,l yWhourmladn!! " to the stack
       ⟛      pop 2 and the string and push every 2nd character of the string
               implicit output

बिना गिने हुए वर्ण:

 "..."

               no-op
 "..."         push "Hello, World!" to the stack
               implicit output

Comments

इसका मतलब है कि आपको यह कहने की ज़रूरत नहीं है कि यह गैर-प्रतिस्पर्धी है।

— FryAmTheEggman 20

लेकिन आप सभी समान-अनुक्रमित वर्णों को रखने वाले हैं ... (0-अनुक्रमित) ...

— HyperNeutrino

वूप्स, फिक्स्ड। बस एक और चरित्र lol जोड़ें।

— जुमान

Answer 29

ब्रेनफक, 155 बाइट्स

- - < - < < + [ + [ < + > - - - > - > - > - < < < ] > ] < < - - . < + + + + + + . < < - . . < < . < + . > > . > > . < < < . + + + . > > . > > - . < < < + .

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

हटाया गया हर दूसरा वर्ण:

--<-<<+[+[<+>--->->->-<<<]>]<<--.<++++++.<<-..<<.<+.>>.>>.<<<.+++.>>.>>-.<<<+.

Answer 30

जेली , 32 बाइट्स

 2“HHeelllloo,,  WWoorrlldd!! ”m

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

-2 बाइट्स पूरी तरह से @ के जवाब के लिए धन्यवाद

अब मेरा एक द्वैत> <है

ऊपर जाओ कि एक भी: डी