Viết chương trình không có đầu vào và in Hello, World!ra thiết bị xuất chuẩn hoặc ngôn ngữ thay thế gần nhất với ngôn ngữ của bạn. Điều hấp dẫn là mỗi dòng trong chương trình của bạn chỉ phải chứa các ký tự ASCII có thể in được và nó phải theo thứ tự từ điển, hay còn gọi là sắp xếp.

Dưới đây là tất cả 95 ký tự ASCII có thể in theo thứ tự:

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Vì vậy, ví dụ, dòng !!A0~sẽ không hợp lệ vì Avà 0không đúng thứ tự. Dòng !!0A~này sẽ hợp lệ.

Mỗi dòng trong chương trình của bạn có thể có độ dài bất kỳ và có thể có bất kỳ số lượng dòng nào. Các dòng trống được coi là sắp xếp. Mỗi phòng trong số dòng mới trong chương trình của bạn phải giống nhau (không pha trộn \nvà \r\n). Các tab và các ký tự ASCII không in được đều bị cấm.

Do nhu cầu phổ biến , điều kiện thắng đã được chuyển đổi:
Bài nộp có ít dòng nhất sẽ thắng. Tiebreaker đi đến chương trình ngắn nhất (dòng mới được tính là các ký tự đơn).

Chỉ Hello, World!và một dòng mới tùy chọn nên được đầu ra. Lưu ý rằng HQ9 + không hợp lệ vì nó xuất ra hello, world. Tôi có thể cấm các ngôn ngữ tương tự như HQ9 + có một ký tự "Xin chào, Thế giới!" lệnh do tầm thường của họ.

Dấu:

Điều này chắc chắn có thể có trong Unary và Lenguage , mặc dù không chính xác lắm.

Headsecks , 1 dòng, 366 byte

                                                                        $(((((((((((((((((((((((((((((,000000044888<AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIIIIIIIIIIIILPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPTXXXXXXXXXXXXXXXXXXXXXXXX\```diiiiiilqqqqqqqqtyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy|

Headsecks là một sự thay thế Brainfuck tầm thường trong đó điều duy nhất quan trọng là điểm mã modulo 8. Brainfuck tương đương chỉ đơn thuần là

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.-------------------------------------------------------------------.------------.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+++.------.--------.-------------------------------------------------------------------.

May mắn là cách tiếp cận ngây thơ này chỉ phù hợp. Có một số tiềm năng để chơi golf xuống byte, nhưng nó có thể khó.

Đã thử nghiệm bằng trình thông dịch Python này .

Tạo mã

code = "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.-------------------------------------------------------------------.------------.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+++.------.--------.-------------------------------------------------------------------."
command_map = "+-<>.,[]"

last_point = 32
out = []

for char in code:
    curr_mod = command_map.index(char)
    last_mod = last_point % 8

    if curr_mod > last_mod:
        last_point += curr_mod - last_mod

    elif curr_mod < last_mod:
        last_point += (8 - last_mod) + curr_mod

    out.append(chr(last_point))

print("".join(out))

/// , 7 dòng, 22 byte

/
//Hello
,
 Wor
l
d
!

Cơ hội hiếm có để /// có thể cạnh tranh (miễn là không ai bắt đầu với Unary và Lenguage ...).

Mã đầu tiên gặp a /và phân tích cú pháp

/
//

như một hướng dẫn thay thế loại bỏ tất cả các dòng mới từ phần còn lại của chương trình. Sau đó, chương trình chỉ đọc

Hello, World!

được in nguyên văn vì nó không chứa bất kỳ dấu gạch chéo nào nữa.

JavaScript (67 66 62 dòng, 227 269 ​​byte)

(Lưu ý: chỉ được thử nghiệm trên Firefox 36 và Safari 8, chứa các tính năng ES6 nhỏ ( Setlớp))

Z
=
!""+
(0[[]]
+
(
!!""+Set
));c
=Z[~
-22]
$=Z[
3]
$$=Z[
15]
$$$=Z[
24]
$$$$=Z[
1]
$$$$$=Z[
0]
Set
[c
+
$$$+Z[
5]
+Z[
16]
+
$$$$$+
$$$$+Z[
2]
+c
+
$$$$$+
$$$+
$$$$]
(Z[
14]
+
$$+
$+
$$$$+
$$$$$+
"(\
'H\
"+
$+
$$+
$$+
$$$+
",\
 W\
"+
$$$+
$$$$+
$$+Z[
6]
+
"\
!')\
")
()

Các mã ở trên về cơ bản không:

alert("Hello, World!")

Rõ ràng alertlà không được sắp xếp. Vì vậy, thay vào đó chúng ta cần tạo câu lệnh dưới dạng một chuỗi và "eval" nó:

s = "alert('Hello, World!')";   // generate this using sorted code
eval(s)

Làm thế nào để tạo chuỗi? ES5 hỗ trợ tiếp tục dòng để

"AL\
ERT" === "ALERT"

Nhưng mã ký tự \xuất hiện trước tất cả các chữ cái viết thường, vì vậy chúng ta phải tạo các chữ cái thường bằng các phương thức khác.

Chúng tôi mượn một số ý tưởng về JSFuck ở đây. Các chữ cái viết thường liên quan đến các tuyên bố cảnh báo là:

t e r a o l d

tất cả những thứ này có thể được trích xuất từ ​​các ký tự của các đối tượng tiêu chuẩn, có thể được biểu thị theo một số thứ tự được sắp xếp:

t, e, r ← true      = !""
a, l    ← false     = !!""
o       ← function  = Set
d       ← undefined = 0[[]]

Làm thế nào để chúng ta đánh giá chuỗi? Chắc chắn chúng ta không thể sử dụng eval(s)vì nó không được sắp xếp. Ngoài ra, chúng tôi có thể sử dụng Function(s)(), nhưng chúng tôi không thể sử dụng Functionvì nó cũng không được sắp xếp. Tuy nhiên, Functionlà hàm tạo của tất cả các hàm, có nghĩa là Set.constructor === Function.

Thêm định danh constructorlàm cho danh sách các chữ cái viết thường trở thành:

t e r a o l d c u n s

điều may mắn vẫn có thể được tạo ra bởi "truefalseundefinedfunction":

t, e, r, u ← true      = !""
a, l, s    ← false     = !!""
o, c, n    ← function  = Set
d          ← undefined = 0[[]]

Sau khi chỉnh sửa, mã ở trên sẽ đọc như sau:

// lines 1~8 defines our string containing all lowercase letters we want
Z = true + (undefined + (false + Set))
// Z = "trueundefinedfalsefunction Set() { [native code] }"

// lines 8~20 defines the variables `c`, `$` (e), `$$` (l), `$$$` (o), 
// `$$$$` (r), `$$$$$` (t)
// for the corresponding lowercase letters extracted from `Z`

// the rest calls:
Set["constructor"]("alert('Hello, World')")()
// lines 22~36 generates the "constructor" string
// lines 37~61 generates the "alert('Hello, World')" string

Cập nhật: đổi tên E, L, O, R, Tđể lặp lại hình $để giảm 4 dòng.

Mất ngủ , 4 dòng, 59 byte

 FFFFGjnnnnooty
FLLddeejkopqyyyyy~~
(<ddjnoppppqrtu
<<Fddfj

Chương trình này được tạo ra bằng cách tối ưu hóa cho số lượng dòng.

10 dòng, 43 byte

(u
pt
(dppty
p~
j
<Fptt{
(otz
?o
FLu
<?FFu~

Chương trình trên được tạo ra bằng cách tối ưu hóa số byte.

Bash Cygwin, 16 dòng, 60 byte

Điều này chỉ hoạt động do tên tệp không phân biệt chữ hoa chữ thường trên Windows và thực tế là Cygwin tra cứu các tiện ích không phân biệt chữ hoa chữ thường ngay cả khi bạn không đặt nó để nhận ra đường dẫn không phân biệt chữ hoa chữ thường.

A\
=Hello
A\
+=\
",
"Wor
A\
+=l
A\
+=d
A\
+=\
!
E\
CHO\
 $A

Hãy lưu ý về điều đó ECHOở cuối.

> <> , 6 dòng, 111 byte

  """""""/;;Hello
        &\o
      &++\oooo~~
"++++++++\bbbdlr
    +++++\ccccccccfooo}
    $++66\cfffffooooopr

Tôi gặp khó khăn khi chơi golf thêm một dòng, nhưng trong mọi trường hợp, tôi rất vui vì đã đánh bại phương pháp 7 dòng.

Giải trình

> <> là ngôn ngữ 2D dựa trên ngăn xếp trong đó các hướng dẫn là các ký tự đơn và luồng chương trình có thể lên, xuống, trái hoặc phải. Các "hướng dẫn Toggles chuỗi phân tích cú pháp, đẩy chars cho đến khi một bế mạc "được đáp ứng, nhưng vì bản chất của> <> không có những điều như "đa-line chuỗi phân tích cú pháp" như với chuỗi CJam hoặc chuỗi trích dẫn ba của Python. Điều này hóa ra là một vấn đề lớn bởi vì bắt đầu và kết thúc một dòng với a "và có các ký tự khác ở giữa (ví dụ "some chars") không được phép!

Lưu ý rằng /và \phản ánh luồng chương trình, vì vậy chúng tôi thực sự thực hiện dòng đầu tiên sau đó tất cả các dòng theo thứ tự ngược lại, và hầu hết các dòng thực sự được thực hiện ngược!

[Line 1]

""""""              Three empty strings, push nothing
"/;;Hello  "        Push "/;;Hello  ". Note the wrapping - ><> is toroidal!
""""""              Three empty strings, push nothing

[Line 6]
66++$               Turn the top " " into "," by adding 12, then swap top two
rp                  Reverse stack and pop top 3
ooooo               Print "Hello", stack is now " ,"
fffffc              Push some 15s and a 12

[Line 5]
+++++               Sum the 15s and 12 to give 87, or "W"
}ooo                Move "W" to the back and output ", W"
fcccccccc           Push a 15 and some 12s

[Line 4]
++++++++            Sum the 15 and 12s to give 111, or "o"
"rldbbb\++++++++"   Push chars to stack
r                   Reverse stack
ld                  Push length of stack and 13, not used
bbb                 Push three 11s

[Line 3]
++&                 Sum the 11s to give 33, or "!" and put in register
~~                  Pop top two
oooo                Print "orld"

[Line 2]
&                   Put "!" from register to stack
o                   Print "!"

[Line 1]
;                   Terminate

Bên cạnh đó, đây là một nỗ lực gây cười ở một> <> ít byte nhất (23 dòng, 47 byte):

v
"
!
d
l
r
o
W

,
o
l
l
e
H
"
/<
l
?
!
;
o
\^

CJam, 5 4 dòng, 162 byte

"Hello
")))))))))))))))))))))))))))))))))))68S\cel
"Wor
")))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))@SX\c|

Cùng một số dòng như Mất ngủ! (nhưng nhiều byte hơn)

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

Giải trình

"Hello\n"        Push "Hello" and a newline
)                Uncons the newline
)))...)))        Increment the newline into a ","
68S\             Push 68 and a space then swap, leaving 68 on top
c                Convert 68 into a char "D"
el               Lowercase "D" into "d"
"Wor\n"          Push "Wor" and a newline
)                Uncons the newline
)))...)))        Increment the newline into an "l"
@                Rotate top three elements, moving the "d" to the top
SX\              Push a space and 1 then swap, leaving the space on top
c                Convert the space (which is an array) into a char
|                Bitwise or the space (32) with 1 to give "!" (33)    

CJam tự động in ngăn xếp sau đó.

Cảm ơn @Optimizer đã nhắc nhở tôi rằng nó Schoạt động, vì nếu không thì SX|thất bại (nó thực hiện một setwise hoặc thay vào đó, đưa ra mảng bao gồm một khoảng trắng và 1).

> <> (Cá) , 5 dòng, nhiều byte

Mã này rất dài, khi tôi nói [6535529689086686142930090 '+' signs]và [6535529689086686142930090 'd' characters]trong dòng đầu tiên của mã, tôi có nghĩa là có 6535529689086686142930090các dấu cộng theo nghĩa đen liên tiếp!

(Và đối với các dòng sau, thêm các không gian tiền tố cần thiết.)

'[6535529689086686142930090 '+' signs]^`[6535529689086686142930090 'd' characters]
                                   **,/288
                                     -/:o
                             %**288:;?\
                                   (1:\

Một thay thế có thể kiểm tra ngắn hơn mà chỉ in Hi:

'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++^`hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
                                                                                                                               **,/288
                                                                                                                                 -/:o
                                                                                                                         %**288:;?\
                                                                                                                               (1:\

Phương pháp:

• Trong dòng đầu tiên, chúng tôi tạo ra một số lượng lớn đại diện cho chuỗi trong cơ sở128.
• Trong phần còn lại của dòng (đi từ dưới lên trên) chúng tôi in ký tự sau trong mỗi vòng lặp cho đến khi giá trị của số nguyên đạt 0.
• Mã lặp là :1(?;:882**%:o-288**,.

(Chúng ta có thể in chuỗi ký tự dài hơn 2 ký tự tùy ý bằng phương pháp này.)

PHP (7/17 dòng, 36/59 byte):

Do số lượng câu trả lời không hợp lệ, tôi viết lại câu trả lời này.

Phiên bản trình duyệt? Không còn.

Nhưng tôi có 2 giải pháp, cả hai đều dựa trên chuỗi bitwise xor( ^) trong PHP.

Đây là một giải pháp cực kỳ mạnh mẽ! Đôi khi, nó cho phép tiết kiệm nhiều byte.

Đầu tiên, câu trả lời ngắn nhất:

Echo
Hello
,AM^mm
,Wor
,OOO^
"#+n
";

Tôi biết, nó có vẻ khủng khiếp, nhưng nó hoạt động!

Việc tiếp theo phụ thuộc vào dòng mới.

Có, nó sử dụng các dòng mới ( \n/ kiểu UNIX là bắt buộc)!

Echo
Bo
.ff
.e
.
"&*]ex
fn
"^
"\n
\n
\n
\n
\n
\n
\n
",B^c
;

Các dòng mới về điều này là bắt buộc để làm việc.

Nó không hoàn hảo, nhưng hoạt động!

Cả hai câu trả lời đều dựa trên giải pháp của @ MartinBüttner :

Echo
Hello
.
chr
(44
).
chr
(29
+3
).Wor
.l
.d
."!
";

Cảm ơn đặc biệt đến @ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ , @CJDennis , @ MartinBüttner và @skagedal vì đã phát hiện tất cả các lỗi của tôi và cho các đề xuất của họ.

Pyth, 7 dòng, 23 byte

-
"Hello
,
 Wor
l
d
!"b

Khá đơn giản, chỉ cần sử dụng một chuỗi nhiều dòng và loại bỏ các dòng mới.

Hãy thử nó ở đây.

Forth, 41 dòng, 143 byte

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

Tôi rất tự hào về điều này. Tôi đã đánh cắp nó khá nhanh khi tôi thấy mình có thể làm được, nhờ Google tìm kiếm các ngôn ngữ không phân biệt chữ hoa chữ thường và tôi đã biết rõ về Forth. Nó gần như chắc chắn có thể được rút ngắn, cả byte và dòng. Gợi ý được đánh giá cao. : D

Chương trình này về cơ bản đẩy giá trị thập phân của từng ký tự ASCII, sau đó in từng ký tự. Tôi đã cố gắng tối ưu hóa trong khi tôi viết nó, do đó nó ít đọc hơn tôi muốn.

33
99
1
+
DUp
8
+
2DUp
6
+
SWap
11
+
2OVer
SWap
8
9
*
EMit
1
+
EMit
DUp
DUp
EMit
EMit
3
+
EMit
29
3
2DUp
+
EMit
*
EMit
EMit
EMit
EMit
EMit
EMit

Tuyệt vời, 9 dòng, 94 byte

3333
    @ADD
    358C
++--29\\
++--3555DE
<<<<<<>>~~
+++++446666D
++++++++../\
      ++------

Kiểm tra nó trực tuyến ở đây. Using spaces for blank cellsphải được kiểm tra

Đại diện trực quan của nguồn:

Giải thích: Mỗi giá trị thập lục phân trong chương trình này di chuyển xuống dưới mỗi "đánh dấu" (trừ khi nó bật \\, trong trường hợp này nó di chuyển sang phải). ++sẽ tăng giá trị, --giảm dần, ~~áp dụng một chút không, v.v ... Các giá trị rơi xuống đáy được in dưới dạng ký tự ASCII.

Ví dụ: Ở 33góc trên cùng trở thành (((0x33 +1 +1) << 1) +1 +1 = 0x6C (l).

Perl, 17 dòng

$_
=
'pr
int
"Hello
,
 Wor
l
d
!"';s
!
!!g
;s
!.
*
!$&
!eex

Rebol - 15 dòng (51 byte)

PRin
AJOin
[
'Hello
Sp 
+
12
Sp
'Wor
'l
'd
Sp
+
1
]

Từ Rebol là case-insensitive (ví dụ. PRINT, PrintVàprint tất cả sẽ gọi hàm giống nhau).

Các mã trên được dọn dẹp:

prin ajoin [
    'Hello  sp + 12  sp  'Wor  'l  'd  sp + 1
]

Lưu ý sptrả về không gian char!

Unary , 1 dòng, rất nhiều byte

Mỗi nhân vật trong chương trình này là 0. Nguồn quá dài để đặt ở đây, nhưng nó bao gồm một chuỗi gồm nhiều số không:

327380789025192647555922325233404088310881092761595127419003295178342329930050528932118548

Đây là biểu diễn thập phân cho số nhị phân này:

0b1010010010010010010010010110000010010010010110000010010000010010010000010010010000010001001001001011111000010000010000011110001111001011111000000100000011011011100010010010010010010010100100010010010100000000100001011100001100010010010100011011011011011011100011011011011011011011011100000000010100

Được tạo từ chương trình BrainF *** này:

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

Xem cách tôi tạo nó: http://ideone.com/lMT40p

Batch - 39 dòng (202 byte)

Tôi muốn cắt giảm kích thước bằng cách cho phép mở rộng bị trì hoãn bằng cách chạy mã bên trong cmdcuộc gọi bằng cách sử dụng công /v ontắc, nhưng không thể vượt qua tất cả các carat.

@S^
ET^
LO^
C^
AL^
 EN^
ABL^
E^
DEL^
AY^
E^
DEX^
P^
ANS^
IO^
N
@S^
ET^
 0=Hello
@S^
ET^
 1=^
,^
 Wor
@S^
ET^
 2=l
@S^
ET^
 3=d
@E^
CHO^
 !^
0^
!!1^
!!2^
!!3^
!^^^
!

Không có dòng mới (và carat để thoát dòng mới):

@SETLOCAL ENABLEDELAYEDEXPANSION
@SET 0=Hello
@SET 1=, Wor
@SET 2=l
@SET 3=d
@ECHO !0!!1!!2!!3!^^!

Ruby, 19 dòng, 95 byte

$;=
$>
$;<<
:Hello
$;<<
44::chr
$.=
33::
-1
$;<<
$.::chr
$;<<
:Wor
$;<<
:l
$;<<
:d
$;<<
33::chr

Có thể là hạn chế mã khó thứ hai đối với Ruby mà tôi đã thấy trên trang web này, sau sự quái dị ở đây .

Chỉnh sửa để giải thích: Phương thức đầu ra Ruby duy nhất được sắp xếp là <<phương thức trên STDOUT. Thật không may, hằng số cho STDOUT là$> và >ASCII cao hơn hầu hết các ký hiệu, vì vậy thực sự không thể gọi một phương thức trên nó. Chúng ta cần một câu lệnh gán nhiều dòng để đưa nó vào một tên biến dễ hiểu hơn,$; (dấu chấm phẩy vẫn còn khá cao, nhưng hầu hết các biến của dạng này đều không thể gán được hoặc chỉ có thể là chuỗi).

Biểu tượng ( :Wor, v.v.) là cách dễ nhất để thực hiện nghĩa đen và tôi không thấy cách nào để loại bỏ dòng mới khỏi chuỗi, vì vậy tôi cần nhiều câu lệnh in. Không gian và dấu chấm câu không thể đi vào một ký hiệu theo nghĩa đen, nhưng may mắn là chrphương pháp về số là hợp pháp, vì vậy tôi có thể nhận được một ký tự từ giá trị ASCII của nó. ::là một cách khác của phương thức gọi. Không gian là khó khăn vì tôi không thể viết 32, vì vậy tôi trừ 1 từ 33 và gán nó cho một biến.

Retina, 12 dòng, 29 byte (không cạnh tranh)

Ngôn ngữ mới hơn thách thức.

Hello
$
,
$
 Wor
$
l
$
d
$
!

Dùng thử trực tuyến