Là một phần của phần 2 của Hello, World! (Mỗi nhân vật khác) , viết một chương trình sao cho cả ba của các chương trình in "Hello, World!": Toàn bộ chương trình, 1, 3, 5, vv nhân vật của chương trình của bạn, và lần thứ 2, thứ 4, thứ 6, Vân vân.

Nếu chương trình của bạn là:

abc
def

Nó sẽ xuất ra "Xin chào, Thế giới!", Nhưng vì vậy nên

acdf

Và

b
e

Không có giải pháp nào tích hợp "Xin chào, Thế giới!".

mã máy x86, 378 byte

PROG.COM Tải xuống và chạy nó trong trình giả lập MS-DOS , ví dụ như 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

Ngoài ra, bạn có thể tải xuống LEFT.COM và RIGHT.COM

Cách thức hoạt động và cách chạy

Xem câu trả lời cho phần một

ma thuật

Nếu bạn muốn thực thi lệnh opcode 0xAB với một tham số 0xCD , bạn viết

Máy phát điện

Chạy mã, nhận hex. Chuyển đổi thành nhị phân

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>"));

Python 3 , 115 byte

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

Mỗi nhân vật kỳ quặc

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

Mỗi nhân vật

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

Hãy thử trực tuyến!

Điều này có thể có thể ngắn hơn rất nhiều, nhưng tôi vui vì tôi đã xoay sở để làm cho nó hoạt động trong Python. Tương tự như câu trả lời của vroomfondel ở phần đầu tiên.

Chán 93 câu trả lời

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

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

Mỗi nhân vật kỳ quặc

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

Mỗi nhân vật

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

Hãy thử trực tuyến!

> <> , 45 byte

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

Hoặc thậm chí chỉ các nhân vật:

 "!dlroW olleH"!">o<  

Hoặc chỉ là các ký tự kỳ lạ:

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

Hãy thử chúng trực tuyến: bản gốc , evens , tỷ lệ cược .

Phiên bản gốc đẩy " !!ddllrrooWW oolllleeHH" vào ngăn xếp, sau đó con cá nảy lên giữa >~o <, xóa một chữ cái, in hai, xóa hai, in hai, xóa hai, v.v. Hai chương trình nửa là các chương trình in chuỗi khá chuẩn. Phần khó khăn là kết hợp "và !chuyển đổi trong và ngoài chế độ chuỗi trong cả ba chương trình một cách chính xác.

Befunge-98 , 43 byte

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

Hãy thử trực tuyến!

Chỉ những người lẻ:

10x"!dlroW ,olleH"ck,@

Hãy thử trực tuyến!

Chỉ những người chẵn:

2 "!dlroW ,olleH"ck,@

Hãy thử trực tuyến!

Giải trình

Chương trình đầy đủ:

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.

Trong chương trình lẻ, cái 2đã biến mất, do đó 10xthực sự không có gì cả (dù sao nó cũng đặt delta (1,0)là mặc định). Phần còn lại của chương trình là như nhau.

Trong chương trình chẵn, chúng ta chỉ cần đẩy vào 2lúc bắt đầu mà chúng ta có thể bỏ qua hoàn toàn. Phần còn lại của chương trình vẫn giống như trước đây.

Gammaplex , 46 byte

//

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

Xem tại đây.

Thông dịch viên. Nó có thể cần một số thay đổi để làm việc trong trình biên dịch hiện đại.

Toán học, 65 byte

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

Nó ném một số cảnh báo, in Hello, World!và trả lại Null PPrriinntt[["" HHeelllloo, Null, "" WWoorrlldd!!]]. Khi chạy dưới dạng chương trình (không phải trong REPL), giá trị trả về sẽ không được in.

Sau khi xóa các ký tự chẵn:

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

Nó in Hello, World!và trả lại"el,Wrd" Null Pit.

Sau khi xóa các ký tự lẻ:

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

Nó in Hello, World!, và trả lại Null ol! rn[Hlo].

mã máy x86, 73 byte

Lấy cảm hứng từ giải pháp của Егггггггггггг Tôi vẫn đang thử với một biến thể thông minh sử dụng lodsb; lodsblàm điểm trung tâm (vì vậy chỉ cần một hằng chuỗi cho tất cả các biến thể)

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

Nếu tôi nhớ lại chính xác từ những ngày thơ ấu, mô hình nhỏ bé của COM bắt đầu bằng DS=CS=SSvà mã được tải bắt đầu từCS:0100h . Tôi không cho rằng nó được đảm bảo rằng mã được tải vào một khối bộ nhớ zero (nếu nó được đảm bảo, tôi có thể giảm hai byte).

Việc tháo gỡ mã dài phải được

  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"

Tháo mã lẻ

  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"

Tháo gỡ mã chẵn:

  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"

Võng mạc , 48 byte

G |`

HHeelllloo,,  WWoorrlldd!!
$_&

(.)\1t?
$1

Hãy thử trực tuyến!

Vị trí kỳ lạ:

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

Hãy thử trực tuyến!

Ngay cả các vị trí:

 `
Hello, World!$&
.\t
1

Hãy thử trực tuyến!

Giải trình

Chương trình đầy đủ:

G |`

Điều này không có gì cả. Đây |không phải là một tùy chọn cấu hình hiện có. Điều Gnày làm cho đây là một giai đoạn grep, nhưng thực sự không có gì để được grepping và regex là trống rỗng, vì vậy điều này không làm gì cả. Mục đích của giai đoạn này là có hai nguồn cấp dữ liệu chính trước "Xin chào, thế giới!" để một trong số họ luôn sống sót sau khi giảm. Lý do để biến điều này thành một grep stag là vì chúng ta cần bù lại tính chẵn lẻ của các dòng và các giai đoạn grep chỉ yêu cầu một dòng duy nhất.

HHeelllloo,,  WWoorrlldd!!

Điều này biến chuỗi làm việc (trống) thành đầu ra cần thiết với mỗi ký tự được nhân đôi.

$_&

Điều này không có gì. Regex cố gắng khớp a _và a &sau khi kết thúc chuỗi tất nhiên là không thể. Tuy nhiên, chúng ta sẽ cần những nhân vật trong phiên bản rút gọn, một lần nữa để đối phó với các nguồn cấp dữ liệu biến mất.

(.)\1t?
$1

Cuối cùng, chúng tôi loại bỏ các ký tự trùng lặp bằng cách thay thế (.)\1bằng $1. Điều t?này không bao giờ được sử dụng nhưng sẽ lại cần thiết trong các phiên bản rút gọn.

Chương trình lẻ:

G|
Hello, World!

Không Gthể khớp với đầu vào trống, nhưng đó là lý do tại sao chúng ta phải |cho phép một kết quả trống thay thế. Điều này biến chuỗi làm việc trống thành đầu ra mong muốn.

_
()1?$

Điều này thay thế dấu gạch dưới bằng ()1?$, nhưng không có dấu gạch dưới trong chuỗi, vì vậy điều này không làm gì cả.

Chương trình chẵn

 `
Hello, World!$&

Các `chỉ biểu thị một chuỗi cấu hình sản phẩm nào, vì vậy chúng tôi một lần nữa sử dụng regex trống để thay thế các chuỗi làm việc với đầu ra. Lần này chúng tôi cũng chèn $&nhưng đó là trận đấu, tất nhiên là trống, vì vậy nó không làm gì cả.

.\t
1

Điều này sẽ thay thế bất kỳ ký tự nào được theo sau bởi một tab bằng một 1, nhưng chúng tôi không có bất kỳ tab nào, vì vậy đây cũng là một không có.

Lua , 106 byte

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

Hãy thử trực tuyến!

Thay thế 1:

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

Hãy thử trực tuyến!

Thay thế số 2:

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

Hãy thử trực tuyến!

Kịch bản thay thế: Hãy thử trực tuyến!

CJam , 44 byte

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

Hãy thử trực tuyến!

PHP, 70 byte

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

Nhân vật kỳ lạ:

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

Ngay cả các nhân vật:

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

Haskell , 92 byte

{---- }

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

Hãy thử trực tuyến! Có vẻ như lạm dụng bình luận là quá nhiều cho việc đánh dấu cú pháp để xử lý. {- ... -}là một nhận xét nội tuyến hoặc nhiều dòng, trong khi --bắt đầu một nhận xét dòng.

Nhân vật kỳ lạ:

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

Hãy thử trực tuyến!

Ngay cả các nhân vật:

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

Hãy thử trực tuyến!

Zsh , 54 byte

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

Hãy thử trực tuyến!

Chương trình chính thực hiện thành công câu lệnh đầu tiên, vì vậy câu lệnh sau boolean ||bị bỏ qua.

Đối với lẻ / chẵn, <<<Hello\ world!trở thành một số bị hủy <<heredochoặc <fileđược cung cấp trên stdin. Dù bằng cách nào, sự ||trở thành |, và do đó, bất cứ thứ gì được xuất ra bởi lệnh đầu tiên đều được đưa vào và bỏ qua echo.

LOGO , 71 byte

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

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

(chương trình có một dòng mới)

Hai phiên bản đã xóa:

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

và

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

(chương trình có một dòng mới)

Để được giải thích những gì prvà erlàm, xem bài viết này . Trong trường hợp này, erđược cung cấp với một từ xác định tên thủ tục.

Ký \tự thoát trong Logo, sẽ thoát dòng mới sau khi kết thúc nhận xét, do đó làm cho dòng thứ hai ( rHlo ol!e |) của chương trình bị xóa thứ hai trở thành một nhận xét.

Javascript, 68 byte

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

Nhân vật kỳ lạ:

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

Ngay cả nhân vật:

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

Phiên bản sửa đổi của câu trả lời của tôi trên một cái khác.

Perl 5 , 61 byte

Mã 60 byte + 1 cho -p.

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

Hãy thử trực tuyến!

Mỗi Byte lẻ

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

Hãy thử trực tuyến!

Mọi Byte

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

Hãy thử trực tuyến!

BotEngine , 180 178 byte

Dựa trên câu trả lời của tôi cho câu hỏi này .

 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

Các ký tự lẻ (lưu ý nhiều dấu cách ở dòng cuối cùng):

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

Ngay cả các nhân vật:

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

Bùa mê , 52 byte

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

Hãy thử trực tuyến!

Runic thường không giỏi xử lý bức xạ vì loại bỏ các ký tự điều khiển dòng chảy một cách ngẫu nhiên làm cho việc thực hiện theo dõi trở thành một nỗi đau lớn, nhưng bức xạ có thể dự đoán được như mọi nhân vật khác? Thật dễ dàng, chúng tôi chỉ mã hóa hai chương trình được đảo ngược lẫn nhau và xen kẽ, sau đó xử lý một bản sao thứ ba để thực hiện cơ sở và kiểm soát chương trình nào được thực hiện với một ký tự. Trong chương trình 2, bản sao thứ ba là rác chưa từng thấy và trong chương trình 3, nó giữ lại các trích dẫn, cho phép nó được bật lên mà không cần in.

Chương trình 1 chỉ thực hiện phần này:

 L                                  @"!dlroW ,olleH"

Chương trình 2 chỉ thực hiện phần này:

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

Như thế này:

  "Hello, World!" @!lo olH

Hãy thử trực tuyến!

Chương trình 3 chỉ thực hiện phần này:

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

Như thế này:

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

Hãy thử trực tuyến!

Các "drW,le"phần được thực thi, nhưng ~ngay lập tức bật nó ra khỏi ngăn xếp, bảo quản sản lượng mong muốn.

Rõ ràng là một chuyển đổi của câu trả lời> <> sẽ dẫn đến một chương trình ngắn hơn, nặng 45 byte:

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

Tuy nhiên, Runic có một hạn chế là> <> không có: kích thước ngăn xếp tối đa 10 mana của IP (ban đầu là 10). Và !!ddllrrooWW oolllleeHHchứa 24 ký tự, làm cho IP bị chảy mana cho đến khi nó hết hạn ngay trước khi thực hiện Rlệnh, dẫn đến không có đầu ra cho chương trình cơ sở.

Hãy thử trực tuyến!