Seperti beberapa dari Anda mungkin tahu, untuk menggunakan bahasa ke Try 's Online yang luar biasa dari Dennis ! , Halo, Dunia! program diperlukan. Baru-baru ini, Dennis mendorong cara untuk memuat program-program ini dari situs web. Berikut adalah pastebin JSON dari karakter yang digunakan dalam program tersebut, berdasarkan frekuensi, per 27 Juli 2017.

Beberapa karakter tersebut membutuhkan cinta, jadi tantangan Anda adalah mengeluarkan Hello, World! (lebih disukai dalam bahasa yang terlibat dalam proses ini), hanya menggunakan karakter yang ditentukan di bawah ini. Karakter-karakter ini adalah semua karakter yang digunakan di antara waktu ( 10dan 99inklusif), bersama dengan dua karakter paling umum, 0dan , karena saya merasa senang.

0 $&*?ABCDEFGIJKLNPQRSTUXYZ\`gjkqwxyz{}÷≤≥=║_

Penggunaan karakter oleh Anda harus didasarkan pada kemunculannya dalam program normal, bukan berdasarkan titik kode atau nilai byte.

Anda harus menggunakan setidaknya satu karakter dari set itu, sehingga program 0-length tidak valid.

Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.

JSFiddle untuk memeriksa apakah jawaban Anda valid

SOGL V0.12 , 89 75 68 byte

z{}xxxx≥x≥x≥xXUqXxq≤qq≤q *R_IIRq  q *R_I0II*IRqxXq≤qxqxq CR_0II÷Rq0*

Coba Di Sini!
Catatan: setiap kali qatau output disebut di sini, itu tidak muncul karena output popping (salah satu oOpP) tidak tersedia atau output baris baru.

Penjelasan (usang, yang berubah adalah bahwa "H" dicetak menggunakan huruf alfabet):

 $             push "$"
  R_           convert to an array of ordinals, then push all the contents to the stack
    0II        push 0+1+1 = 2
       *       multiply by that
        R      convert to character
         q     output
          z    push the lowercase alphabet
           {}  iterate over it, pushing each char, and do nothing. Stack: ["H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
stack manipulation:
 xxxx ["H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r"]
 ≥    ["r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q"]
 x    ["r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o"]
 ≥    ["o","r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n"]
 x    ["o","r","H","a","b","c","d","e","f","g","h","i","j","k","l"]
 ≥    ["l","o","r","H","a","b","c","d","e","f","g","h","i","j","k"]
 xxx  ["l","o","r","H","a","b","c","d","e"]
 q    output the "e"
 ≤    ["o","r","H","a","b","c","d","e","l"]
 qq   output the "l" twice
 ≤    ["r","H","a","b","c","d","e","l","o"]
 q    output the "o"

*                       push "*",
 R_                     convert to an array of ordinals, then push all to stack
   II                   increase by 2
     R                  convert back to character
      q                 output
         q              push a space, then output
           *            push "*"
            R_          convert to an array of ordinals, then push all to stack
              I         increase that
               0II      push 0+1+1 = 2
                  *     multiply
                   I    increase
                    Rq  output as character
stack manipulation: (starting stack: ["r","H","a","b","c","d","e","l","o",","," ","W"])
 x  ["r","H","a","b","c","d","e","l","o",","]
 X  ["r","H","a","b","c","d","e","l","o"]
 q  output the "o"
 ≤  ["H","a","b","c","d","e","l","o","r"]
 q  output the "r"
 x  ["H","a","b","c","d","e","l"]
 q  output the "l"
 x  ["H","a","b","c","d"]
 q  output the "d"

C            push "C"
 R_          convert to ordinal as before
   0II÷      floor divide by 2
       Rq    output as character
         0*  multiply by 0 so nothing extra would be outputted

Fakta menyenangkan: semua karakter dari karakter yang diizinkan berada dalam codepage SOGLs: D

Perl 5 , 76 byte

}{${$_=$`x?B?}{?\w$?}{$_=qq{Lg\LLL$&= w$&RLD=}&qq=y}\LLL$&L _$&RLDA=}=$_=\*G

Ini menggunakan fitur yang sudah usang, tetapi bekerja secara lokal di terminal saya (yang merupakan versi 5.18.2 seperti yang disebutkan). Dalam versi yang lebih lama Perl ?\w?adalah sinonim /\w/yang memberi saya akses ke pencocokan regexp dan saya memiliki cukup karakter untuk $&(pertandingan terakhir) dan $`(teks sebelum pertandingan terakhir). Saya perlu ini untuk bisa mendapatkan O. Saya membuat ini menjadi globreferensi ( $_=\*Gyang, dilemparkan ke skalar, adalah sesuatu sepertiGLOB(0x7ffb728028d0) ). Setelah itu di $_, ?B?akan cocok dengan Bdan $`akan berisi GLO, saya kemudian bisa cocok melawan \w$yang akan menyimpan Odi$&yang dimasukkan ke dalam string yang saya jalankan stringwise-DAN untuk membuat sisa teks, tubuh string menggunakan huruf kecil \L.

Cobalah online! - Penggunaan /\w/sebagai pengganti ?\w?karena versi Perl pada TIO terlalu baru.

Perl 5 , 65 byte

Ini sedikit lebih curang karena bergantung pada nama file di TIO (yang .code.tio), jadi saya tidak benar-benar berpikir ini bersaing, tapi saya senang dengan hasilnya!

}{${$_=$0}{?\w$?}{$_=qq{Lg\LLL$&= w$&RLD=}&qq=y}\LLL$&L _$&RLDA=}

Cobalah online!

Unary , 7 * 10 ¹⁸² byte

Unary adalah Brainfuck dikonversi menjadi biner dikonversi ke unary menggunakan 0sebagai penghitung. Pada dasarnya, ini memadatkan program Brainfuck menjadi angka dan hasilnya adalah angka 0s. Mereka biasanya program yang sangat besar.

Saya tidak akan menempelkan program di sini karena saya tidak tahu berapa banyak teks yang diizinkan SE tetapi saya yakin itu kurang dari ini. Sebagai gantinya, saya akan menempelkan jumlah nol yang tepat dalam jawaban ini:

708184005756841022918598670049178934705323143517361395031673227349803938380119378597780037353721967636097362645175347036417214959141923667629285233360306016978751166690464736541968556

Karena ini adalah jawaban yang cukup murah, dijamin bukan yang tersingkat, dan saya hanya menyalinnya , saya membuat ini sebagai posting wiki.

05AB1E , 137 106 95 byte

X00X00DXX00DXX00XX0X0X00D0XXXX0X00X00XXX00XXX0XXXXXX00XXXXX0XXXX00D0X000DD00XXJC000gDD0000g***B

Cobalah online!

-31 terima kasih kepada @Adnan karena telah menunjukkan saya bisa menggunakan basis 108.

- ?? terima kasih kepada @Riley karena menunjukkan beberapa hal yang salah.

Versi lama (metode berbeda):

05AB1E , 211 186 166 byte

0g00g000000000gUX000000gXX00000g000g00g000gD0000g0 000g00000gX00000gX00000g0 00000g00000000g0000000g00g00000000gD000000gX0000000g0g00000gUXJX00000000000000000g000g**B

Cobalah online!

Ha ha! DAN DI SINI SAYA PIKIR ESOLANG TETAP TANPA KESEMPATAN YANG DAPAT DITERIMA!

Pertama kita mendapatkan 255 disimpan dalam X:

00g               # Push 2 (length of 00).
   00000g         # Push 5 (length of 00000).
         00000g   # Push 5.
               JU # Join to 255 and store in X.

Kemudian, dengan menggunakan trik panjang yang sama kita dorong: 1296995323340359595058728869715

0g00g000000000g000000g000000000g000000000g00000g000g00g000g000g0000g0 000g00000g000000000g00000g000000000g00000g0 00000g00000000g0000000g00g00000000g00000000g000000g000000000g0000000g0g00000gJ

Di mana kita hanya menggunakan 0<space>bukan trik panjang untuk nol.

Kemudian, akhirnya, kami mendorong 255 yang kami simpan dan konversi dari 255 ke basis 10 :

X  # Push stored 255.
 B # Convert to base 255.

Masih bermain golf menggunakan karakter yang diizinkan lainnya, dan duplikasi, itu akan menjadi satu menit.

Beatnik , 148 byte

K QQQQQQQG ZD XA K QQJA KD ZD XA K KG KD ZD ZD ZD XA XA K B KD ZD XA K QQQQF ZD ZD XA K QQQD XA K A Z KD XA ZD XA K B KD XA ZD XA K J Z XA K QQQB XA

Cobalah online!

Penjelasan

Beatnik mendasarkan instruksi yang dieksekusi berdasarkan skor scrabble dari kata tersebut. Berikut penjelasan singkat:

Code         Scrabble Score   Explanation

K            5                push the scrabble score of the next word
QQQQQQQG     72               72 ['H']
ZD           12               pop a value; push it back twice
XA           9                pop a value; print its ASCII character
KD           7                pop two values; push their sum
Z            10               pop two values; push their difference

Moorhens (v2.0), 3423 983 923 866 749 716 byte

Saya pikir ini bisa sedikit golf, Moorhens bukan bahasa yang mudah untuk dikerjakan.

xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU KA AA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU KA KA xU xU xU AA AA AA AA AA KA xU AA KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU KA XI XI XI XI XI XI KA XI XI XI XI XI XI XI XI AA AA AA AA AA AA AA AA AA AA AA AA

Penjelasan

Moorhens adalah bahasa berbasis kata-kata kamus. Setiap kata berhubungan dengan operasi berdasarkan hash-nya. Lima operasi yang digunakan di sini adalah xU, ER, XI, KA, danAA

• xU menambah TOS
• ER menempatkan nol baru di tumpukan.
• XI menurunkan TOS
• KA menduplikasi TOS
• AA menggulung TOS ke bawah

Kami mendorong setiap surat dengan aplikasi sukses dari operasi ini.

Glypho , 480 byte

AABCABABABBAABABAABCABBAABABABBCABBAABABABABABABABBAABBAABABABABABABABBAABBAAABCABBAABABAABCAABCABBAABABABBCABABABBAABBAABABAABCAABCABBAAABCABBAABABABBAABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABAAABABAABAABBAABCAABABABBAABBAAABCAABCABBAABABABBCABABABBCABABABBAABAAABABAABAABABABBAABABABBAABABABAAABABAABAABBAABABABBAAABCABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABCAABAAABABAABAABBAABABABBCAABCABBAAABCAABCABBAAABCABBAABABABBAABABABBCABABABBAABAAABABABCAABBAAABAABACABBBABCB

Cobalah online!

Headecks , 78 byte

yyzyzzxNxNzx{yyy{y{y{yzzz_{_zzyy\zxxxxxx\zzy\\zz\zx\{{\{{\zzz\xxx\{{\{{y\zzzx\

JavaScript Ganda, 318 byte

Saya tidak yakin apakah itu diizinkan, saya tidak bisa melakukannya menggunakan penerjemah JavaScript sekali. Ini mirip dengan menggunakan eval()tetapi sebaliknya saya menggunakan penerjemah dua kali: (Cobalah di konsol untuk mendapatkan hasil yang dicetak kembali)

`\`\\x${0xA*0xA&0xC}${0xA&0xC}\\x${0xA*0xF&0xF}${0xB*0xF&0xF}\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}F\\x${0xE*0xF&0xF}C\\x${0xE*0xF&0xF}${0}\\x${0xB*0xF&0xF}${0xB*0xB*0xF&0xF}\\x${0xA*0xF&0xF}F\\x${0xB*0xB*0xF&0xF}${0xE*0xF&0xF}\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}${0xA*0xA&0xC}\\x${0xE*0xF&0xF}${0**0}\``

Cobalah online!

Mengevaluasi ke:

`\x48\x65\x6C\x6C\x6F\x2C\x20\x57\x6F\x72\x6C\x64\x21`

Cobalah online!

Yang dievaluasi menjadi Hello, World!

Smallf ** k , 266 byte:

zJ$NJ`ZZx*gQYQQ{zqyKKUkUR?AS`zB`JB&UCKCIxQ_G0*000FzzJ&?YwkC\qqgZ`xYQyC}DgY_&_S}KPZ\&?SGAE&{Gw_w} GAgA{qT{gC&`qI?xwCNQwgR}?{*QEwQUj&BT&jR__IJJIqUqAPF0yICXESL?AYR QIAFU& yYwE&$\Njj B0T*F j$?kCzQk*}U}UgI$}Ew_yDL`qYI*E_G}SCjXDFNJKGNIGyIwA\BzLP`*zCILGCNqyYZyq? GwN{q{gKSj

Sebenarnya, karakternya agak tidak relevan. Hanya masalah apakah masing-masing karakter memiliki codepoint genap atau codepoint ganjil. Jadi, saya telah berusaha untuk menggunakan setiap karakter yang tersedia (kecuali karakter multibyte) (meskipun sejak itu diacak, saya tidak berusaha untuk menjamin itu).

Pyke , 133 144 byte

? BXKKKKRKRKRK\CkJ00q}}}XEjTX}G_E\E\L\LkJjRT}}XRGREkJjR 00q}R? B_RE\ \wkJjRT}}XRGRE\R\L\DkJjRZ0q}}R? B_RER? JR? KREZjZ0q}AREkJjRT}}RG_RE00q}}RAA

Cobalah online!

Kekacauan kode yang mengerikan yang hampir pasti dapat dipersingkat ... Membangunnya satu karakter pada satu waktu.

? BXKKKKRKRKRK\CkJ - ".C" - A string that when evaled, gets the character at the point
00q}}}XEj - Construct 64 by doing `((0==0)*2*2*2)**2` and then eval, getting the "@" character and store it in `j`
TX}G_E - Get "h" using `@` by looking it up in the alphabet
\E\L\LkJ - "hELL"
jRT}}XRGREkJ - "hELLo"
jR 00q}R? B_RE  - ","
\ \wkJ - "hELLo, w"
jRT}}XRGRE\R\L\DkJ - "hELLo, woRLD"
jRZ0q}}R? B_RER? JR? KREZjZ0q}AREkJ - "hELLo, woRLD!"
jRT}}RG_RE00q}}RAA - "Hello, World!"

dc , 164 162 byte

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzS zzS?zzzzzzzzzzzzS$zzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzzzzzzzzzzzzzzzSwzzzzzzzzzzzzzzzPzzzzzzzzSLzPzPzzzzPL$PL PLwPzPzzzzPLLPAI*PL?P

Cobalah online!

Kemungkinan ada pendekatan yang lebih baik / lebih menarik. Saya mencoba menggunakan trik ASCII + 256 itudc dimiliki, tetapi menghasilkan karakter tambahan juga (bahkan jika mereka non-printing), dan begitu saya mendapatkan 'o', 111 yang sangat bagus, saya mengalami kesulitan bahkan mendapatkan nilai 111+ (kelipatan 256) yang diperhitungkan dengan bersih. Jadi, inilah solusi yang cukup mudah (meskipun golf jika memungkinkan):

In dc, zadalah perintah yang mendorong kedalaman tumpukan ke tumpukan. Itu berarti kita bisa menggunakannya sebagai kenaikan. Ini adalah bagaimana saya membuat sebagian besar nilai ASCII saya untuk tantangan ini (dicetak dengan P), yang saya dorong ke tumpukan bernama Sdan muncul kembali ke tumpukan utama denganL .

dcmemungkinkan Anda menggunakan nilai hex AF bahkan ketika radix input desimal (default). Untungnya, huruf pertama kami, 72, adalah kelipatan dari 12, jadi saya menyimpan satu atau dua byte di sini dengan mengalikan 6 * 12 dan mencetak segera ( zzzzzzzC*P).Versi 164-byte saya menggunakan perkalian sejak awal untuk mendapatkan 72 ('H'), yang agak pintar tetapi peninggalan dari upaya sebelumnya, dan buang-buang byte. Sekarang, saya mulai dengan menambah dan menghemat ruang, tanda seru, dan koma, yang rusak, dan karena itu belum dapat dicetak. Selanjutnya, saya datang ke 'H', yang segera saya cetak, sebelum saya sampai ke 'W', yang harus saya simpan nanti.

Saya hanya mencetak ketika saya menekan 'e', ​​lalu saya menambah hingga 'l'. Saya mencetak dua dari itu dan menyimpan satu. Ketika saya membuat ke 'o', saya pertama kali pikir saya akan harus menyelamatkan salah satu dari mereka untuk nanti, tapi semuanya jenis agar pada saat ini. Saya mencetak 'o', mengambil koma, spasi, dan 'W' dari sebelumnya, dan sekarang saya segera kembali ke 'o'. Saya mencetak ini, dan menambah beberapa hingga nilai tertinggi yang diperlukan, 'r' (114), yang saya cetak sebelum memuat dan mencetak 'l' yang saya masukkan sebelumnya.

Hampir selesai! 'd' adalah nilai ASCII 100, yang mudah dibuat dengan mengalikan 10 * 10 (lebih sedikit byte daripada menyimpannya sebelumnya dan memuatnya sekarang). Nilai hex Aadalah 10, seperti input radix kami yang dapat kita ambil dengan perintah I. Lipat gandakan, cetak, lalu muat dan cetak tanda seru kami dari yang sebelumnya. Halo Dunia!