Tulis program yang tidak mengambil input dan mencetak Hello, World!ke stdout atau alternatif terdekat bahasa Anda. Tangkapannya adalah bahwa setiap baris dalam program Anda hanya harus berisi karakter ASCII yang dapat dicetak dan harus dalam urutan leksikografis, alias disortir.

Berikut adalah 95 karakter ASCII yang dapat dicetak secara berurutan:

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

Jadi, misalnya, saluran !!A0~akan tidak valid karena Adan 0tidak berfungsi. Baris !!0A~tersebut akan valid.

Setiap baris dalam program Anda mungkin panjangnya dan mungkin ada sejumlah baris. Garis kosong dianggap diurutkan. Setiap baris baru dalam program Anda harus sama (tanpa pencampuran \ndan \r\n). Tab dan karakter ASCII yang tidak dapat dicetak lainnya dilarang.

Karena permintaan populer , kondisi kemenangan telah berubah:
Pengajuan dengan garis paling sedikit menang. Tiebreaker pergi ke program terpendek (baris baru dihitung sebagai karakter tunggal).

Hanya Hello, World!dan baris tambahan opsional yang harus dikeluarkan. Perhatikan bahwa HQ9 + tidak valid karena hasilnya hello, world. Saya mungkin melarang bahasa yang mirip dengan HQ9 + yang memiliki satu karakter "Halo, Dunia!" perintah karena hal-hal sepele mereka.

Petunjuk:

Ini sangat mungkin dilakukan di Unary dan Bahasa , meskipun tidak terlalu ringkas.

Headecks , 1 baris, 366 byte

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

Headsecks adalah substitusi Brainfuck yang sepele di mana satu-satunya hal yang penting adalah kodeo modulo 8. Brainfuck yang setara hanyalah

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

Untungnya pendekatan naif ini hanya cocok. Ada beberapa potensi untuk menurunkan byte, tetapi mungkin sulit.

Diuji menggunakan juru bahasa Python ini .

Menghasilkan kode

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 baris, 22 byte

/
//Hello
,
 Wor
l
d
!

Kesempatan langka untuk /// menjadi kompetitif (juga selama tidak ada yang memulai dengan Unary dan Bahasa ...).

Kode pertama kali bertemu a /, dan mem-parsing

/
//

sebagai instruksi substitusi yang menghapus semua baris baru dari sisa program. Setelah itu, program hanya membaca

Hello, World!

yang dicetak kata demi kata karena tidak mengandung garis miring lebih lanjut.

JavaScript (67 66 62 baris, 227 269 ​​byte)

(Catatan: hanya diuji pada Firefox 36 dan Safari 8, berisi fitur ES6 kecil ( Setkelas))

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]
+
"\
!')\
")
()

Kode di atas pada dasarnya tidak:

alert("Hello, World!")

Jelas alerttidak diurutkan. Jadi alih-alih kita perlu membuat pernyataan sebagai string, dan "eval" itu:

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

Bagaimana cara menghasilkan string? ES5 mendukung kelanjutan garis sehingga

"AL\
ERT" === "ALERT"

Tetapi kode karakter \muncul sebelum semua huruf kecil, jadi kita harus membuat huruf kecil menggunakan metode lain.

Kami meminjam beberapa gagasan tentang JSFuck di sini. Huruf kecil yang terlibat dalam pernyataan peringatan adalah:

t e r a o l d

semua ini dapat diekstraksi dari karakter objek standar, yang dapat dinyatakan dalam beberapa urutan yang diurutkan:

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

Bagaimana kita mengevaluasi string? Tentunya kita tidak bisa menggunakan eval(s)karena tidak diurutkan. Atau kita dapat menggunakan Function(s)(), tetapi kita tidak dapat menggunakan Functionkarena tidak diurutkan juga. Namun, Functionadalah konstruktor dari semua fungsi, yang artinya Set.constructor === Function.

Menambahkan pengenal constructormembuat daftar huruf kecil menjadi:

t e r a o l d c u n s

yang untungnya masih bisa dihasilkan oleh "truefalseundefinedfunction":

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

Setelah prettifying, kode di atas seharusnya berbunyi seperti:

// 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

Update: Berganti nama E, L, O, R, Tberbagai pengulangan $untuk mengurangi 4 baris.

Insomnia , 4 baris, 59 byte

 FFFFGjnnnnooty
FLLddeejkopqyyyyy~~
(<ddjnoppppqrtu
<<Fddfj

Program ini dihasilkan dengan mengoptimalkan jumlah baris.

10 baris, 43 byte

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

Program di atas ini dihasilkan dengan mengoptimalkan jumlah byte.

Cygwin bash, 16 baris, 60 byte

Ini hanya berfungsi karena nama file case-insensitive pada Windows, dan fakta bahwa Cygwin mencari utilitas case-insensitive bahkan jika Anda tidak mengaturnya untuk mengenali path case-insensitive.

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

Catat itu ECHOdi akhir.

> <> , 6 baris, 111 byte

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

Saya mengalami kesulitan bermain golf di jalur tambahan, tetapi bagaimanapun saya senang telah mengalahkan metode 7-line.

Penjelasan

> <> adalah bahasa 2D berbasis stack di mana instruksi adalah karakter tunggal dan aliran program bisa naik, turun, kiri atau kanan. The "instruksi matikan parsing string, mendorong chars sampai penutupan suatu "terpenuhi, tetapi karena sifat> <> tidak ada hal seperti "multi-line parsing string" seperti dengan string CJam atau tiga senar dikutip Python. Ini ternyata menjadi masalah besar karena memulai dan mengakhiri garis dengan a "dan memiliki karakter lain di antara (misalnya "some chars") tidak diperbolehkan!

Perhatikan itu /dan \mencerminkan aliran program, jadi kami benar-benar mengeksekusi baris pertama kemudian semua baris dalam urutan terbalik, dan sebagian besar baris sebenarnya dieksekusi mundur!

[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

Di samping catatan, inilah upaya yang lucu di> <> paling tidak byte (23 baris, 47 byte):

v
"
!
d
l
r
o
W

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

CJam, 5 4 baris, 162 byte

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

Jumlah baris yang sama dengan Insomnia! (tapi lebih banyak byte)

Cobalah online .

Penjelasan

"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 secara otomatis mencetak tumpukan setelahnya.

Terima kasih kepada @Optimizer untuk mengingatkan saya bahwa itu Scberfungsi, karena jika tidak SX|gagal (ia melakukan setwise atau sebaliknya, memberikan array yang terdiri dari spasi dan 1).

> <> (Ikan) , 5 baris, banyak byte

Kode ini sangat panjang, ketika saya katakan [6535529689086686142930090 '+' signs]dan [6535529689086686142930090 'd' characters]di baris pertama kode, maksud saya ada 6535529689086686142930090tanda plus secara berturut-turut!

(Dan untuk baris berikut tambahkan spasi awalan yang diperlukan.)

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

Alternatif yang dapat diuji lebih pendek yang hanya mencetak Hi:

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

Metode:

• Di baris pertama kita membuat angka besar yang mewakili string di base128.
• Di sisa baris (pergi dari bawah ke atas) kita mencetak karakter berikut di setiap loop sampai nilai integer mencapai 0.
• Kode pengulangan adalah :1(?;:882**%:o-288**,.

(Kami dapat mencetak string panjang 2+ karakter acak dengan metode ini.)

PHP (7/17 baris, 36/59 byte):

Karena jumlah jawaban yang tidak valid, saya menulis ulang jawaban ini.

Versi peramban? Hilang.

Tapi saya punya 2 solusi, keduanya berdasarkan bitwise xor( ^) dari string di PHP.

Ini adalah solusi yang sangat kuat! Terkadang, ini memungkinkan untuk menyimpan banyak byte.

Pertama, jawaban terpendek:

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

Saya tahu, ini terlihat mengerikan, tetapi berhasil!

Yang berikutnya tergantung pada baris baru.

Ya, ia menggunakan baris baru ( \n/ gaya UNIX diperlukan)!

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

Baris baru yang satu ini diperlukan untuk bekerja.

Itu tidak sempurna, tetapi berhasil!

Kedua jawaban didasarkan pada @ MartinBüttner 's solusi :

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

Terima kasih khusus kepada @ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ , @CJDennis , @ MartinBüttner dan @skagedal untuk mendeteksi semua kesalahan saya dan atas saran mereka.

Pyth, 7 baris, 23 byte

-
"Hello
,
 Wor
l
d
!"b

Cukup sederhana, cukup gunakan string multiline dan hapus baris baru.

Coba di sini.

Keempat, 41 baris, 143 byte

Cobalah online.

Saya sangat bangga dengan ini. Saya mencabutnya dengan cepat begitu saya tahu saya bisa melakukannya, setelah Google mencari bahasa yang tidak peka terhadap huruf besar-kecil, dan saya sudah mengenal Forth dengan baik. Ini hampir pasti dapat dipersingkat, baik byte dan garis. Saran sangat dihargai. : D

Program ini pada dasarnya mendorong nilai desimal dari setiap karakter ASCII, lalu mencetak masing-masing. Saya mencoba untuk mengoptimalkan sementara saya menulisnya, karena itu kurang dapat dibaca daripada yang saya inginkan.

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

Marbelous, 9 baris, 94 byte

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

Uji secara online di sini. Using spaces for blank cellsharus diperiksa.

Representasi visual dari sumber:

Penjelasan: Setiap nilai heksadesimal dalam program ini bergerak ke bawah setiap "centang" (kecuali jika aktif \\, dalam hal ini bergerak ke kanan). ++akan menambah nilai, --mengurangi, ~~menerapkan bitwise tidak, dll. Nilai yang jatuh dari bagian bawah dicetak sebagai karakter ASCII.

Misalnya: Di 33sudut atas menjadi (((0x33 +1 +1) << 1) +1 +1 = 0x6C (l).

Perl, 17 baris

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

Rebol - 15 baris (51 byte)

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

Kata-kata dalam Rebol tidak peka huruf besar-kecil (mis. PRINT, PrintDan printsemuanya akan memanggil fungsi yang sama).

Kode di atas dirapikan:

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

NB. spmengembalikan char ruang !

Unary , 1 baris, banyak byte

Setiap karakter dalam program ini adalah 0. Sumbernya terlalu panjang untuk dimasukkan di sini, tetapi terdiri dari string dari banyak nol ini:

327380789025192647555922325233404088310881092761595127419003295178342329930050528932118548

Ini adalah representasi desimal untuk angka biner ini:

0b1010010010010010010010010110000010010010010110000010010000010010010000010010010000010001001001001011111000010000010000011110001111001011111000000100000011011011100010010010010010010010100100010010010100000000100001011100001100010010010100011011011011011011100011011011011011011011011100000000010100

Yang dibuat dari program BrainF *** ini:

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

Lihat bagaimana saya membuatnya: http://ideone.com/lMT40p

Batch - 39 Lines (202 bytes)

Saya ingin mengurangi ukuran dengan mengaktifkan ekspansi yang tertunda dengan menjalankan kode di dalam cmdpanggilan menggunakan /v onsakelar, tetapi tidak dapat melewati semua karat.

@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^
!^^^
!

Tanpa baris baru (dan karat untuk keluar dari baris baru):

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

Ruby, 19 baris, 95 byte

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

Mungkin pembatasan kode tersulit kedua untuk Ruby yang pernah saya lihat di situs ini, setelah monstrositas di sini .

Edit untuk penjelasan: Satu-satunya metode keluaran Ruby yang diurutkan adalah <<metode pada STDOUT. Sayangnya, konstanta untuk STDOUT adalah $>, dan >ASCII lebih tinggi daripada kebanyakan simbol, sehingga tidak mungkin untuk memanggil metode di atasnya. Kita memerlukan pernyataan penugasan multi-baris untuk memasukkannya ke nama variabel yang lebih bisa ditelusuri, $;(titik koma masih cukup tinggi, tetapi sebagian besar variabel dari formulir ini tidak dapat ditentukan, atau hanya berupa string).

Simbol ( :Wor, dll.) Adalah cara termudah untuk melakukan literal, dan saya tidak melihat cara untuk menghapus baris baru dari string, jadi saya perlu beberapa pernyataan cetak. Ruang dan tanda baca tidak bisa masuk ke simbol literal, tapi untungnya chrmetode angka itu legal, jadi saya bisa mendapatkan karakter dari nilai ASCII-nya. ::adalah cara alternatif untuk memanggil metode. Space rumit karena saya tidak bisa menulis 32, jadi saya kurangi 1 dari 33 dan tetapkan ke variabel.

Retina, 12 baris, 29 byte (tidak bersaing)

Bahasa lebih baru daripada tantangan.

Hello
$
,
$
 Wor
$
l
$
d
$
!

Cobalah online