您的目标是写“你好，世界！” （减去引号）。这是一场人气竞赛，因此最多的选民获胜。代码长度将用于打破平局。
只要符合以下规则，一切都会进行：

• 所有字符都必须是字母或数字，因此只能使用字符串“ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789”中的字符。
• 您使用的所有代码都必须在一个文件中，但导入的模块/类/以您喜欢的语言调用的任何内容除外。
• 仅允许使用您选择的语言的标准库/框架（例如，允许使用Python的Math模块，但不允许使用Numpy，Scipy和Pygame）。我将允许使用TkInter，因为它是Python中GUI的事实上的标准。
• 不允许输入，无论是从stdin读取，读取文件，显示图像还是从Web读取。

如果您弄清楚如何在Java中完成操作而又不违反规则，则可得到+10布朗尼点。

在您的标记上，设置代码！

编辑：括号（{}），方括号（[]）和括号（（））是允许的，因为如果没有它们，对于大多数语言来说这几乎是不可能的。我还要删除字符数限制规则。希望这会使它变得更有趣。

编辑^ 2：也允许空格。对不起，我的大脑无法正常工作。>。<

佩尔

有人说，Perl是一种全ASCII噪音就像是随机的符号语言$...这是不正确的：P

s zzHelloq worldmz and s zqzchr 44ze and s zmzchr 33ze and print

让我们将其分解为子表达式：

(s zzHelloq worldmz) and (s zqzchr 44ze) and (s zmzchr 33ze) and (print)

很明显，只要每个表达式返回true，它就会从左到右执行。但是到底是s zqzchr 44ze什么？

在Perl，有一组的“报价状运营商”，它包括 q(str)，qw(li st)，/regex/，s/from/to/等等。事实证明，所有这些运算符都可以使用几乎所有字符作为分隔符，并且有很多特殊之处：开头的括号必须用匹配的括号括起来，并且，如果要使用字母作为定界符，则必须放置一个空格在操作员字母之后（以使其与裸字区分开）。

在这种情况下，我们看到s///（regex替换）运算符的三种用法：

s//Helloq worldm/
s/q/chr 44/e
s/m/chr 33/e

全部以字符分隔z。在/e对最后两个标志导致替换被解释为代码进行评估，而不是文字文本。

关于perl的一个众所周知的事实是，$_除非另有说明，否则大多数操作默认都对内置变量进行操作。所有这三种替换方式都print可以$_在这种情况下进行操作，因此，首先将单词Hello world放入变量中，然后使用字符的数字ascii值修复标点符号，然后打印变量的内容。

C

int main(void) {
  if (putchar(72))
    if (putchar(101))
      if (putchar(putchar(108)))
        if (putchar(111))
          if (putchar(44))
            if (putchar(32))
              if (putchar(87))
                if (putchar(111))
                  if (putchar(114))
                    if (putchar(108))
                      if (putchar(100))
                        if (putchar(33)) 
                        {
                        }
}

（编辑-BBC基本版已按建议移至单独答案。对此的大多数投票肯定是针对LOGO答案的。）

商标

口译员，网址为http://www.calormen.com/jslogo/#

TO h        pd  fd 100 rt  90  pu  fd 50  rt 90  pd  fd 100  rt 180 fd 50  lt 90  fd 50  rt 90  pu END 
TO e        pu  fd 25  rt  90  pd  fd 25  rt 90  arc 270 25  lt 90  fd 25  lt 90  pu END  
TO l        pd  fd 100 pu  END  
TO o        rt  45 fd  35  pd  arc 360 25  lt  45  pu END 
TO comma    pd  rt 90  arc 90  15  lt  90  pu END 
TO w         l  rt 180 l   pd  lt  135 fd  35  rt  90  fd 35  lt 135  l  END  
TO r        pd  fd 25  rt  90  pu  fd  25  rt 180  arc 180 25 rt 90 END 
TO d         o  rt 135 fd  35  lt  135  l  END      
TO exclaim arc 360 5   fd  10  l  END 

clearscreen  
setpencolor 4 pu 
setxy 0 150      h 
setxy 100 150    e  
setxy 200 150    l 
setxy 250 150    l 
setxy 300 150    o 
setxy 350 150    comma  
setpencolor 1 
setxy 0 0        w 
setxy 100 0      o 
setxy 200 0      r  
setxy 300 0      l 
setxy 350 0      d 
setxy 450 0      exclaim 
fd 100

输出（绿色三角形是乌龟光标）

苹果脚本

这一个中完全没有括号[]，大括号{}或括号()：

set s to ASCII character 72
set s to s as list
set end of s to ASCII character 101
set end of s to ASCII character 108
set end of s to end of s
set end of s to ASCII character 111
set end of s to ASCII character 44
set end of s to space
set end of s to ASCII character 87
set end of s to item 5 of s
set end of s to ASCII character 114
set end of s to third item of s
set end of s to ASCII character 100
set end of s to ASCII character 33
display dialog s as text

输出为：

重击

如果您着眼睛，这种作品：

echo NN i NN i i i iNN NNi i i i i i i NN i NN i i i i i i i NNi i i NN NN
echo NN i NNi i i i NN NN i i i i i i iNN i NN i i i i i i i NN i i iNN NN
echo NN i NN iNNNNi NN NN iNNNNi i i i NN i NN iNNNNi NN NN iNN iNNN NN NN
echo NNNNNNN NN iNN NN NN NN iNN i i i NN i NN NN iNN NNN iN NN NN iNNN N
echo NN i NN NNNNNN NN NN NNi NN i i i NN N NN NNi NN NN i i NN NNi iNN N
echo NN i NN NN i i NN NN NN iNN i i i NNN NNN NN iNN NN i i NN NN i NN
echo NN i NN iNNNi iNN NN iNNNNi N i i NN i NN iNNNNi NN i i NN iNNNN N NN
echo i i i i i i i i i i i i i i N

base64

SGVsbG8sIFdvcmxkIQ

满足原始规则。

蟒蛇

那么，我们只是假设每个人都水平阅读？对于那些喜欢垂直阅读的用户：

print chr(72) 
print chr(101)
print chr(108)
print chr(108)
print chr(111)
print chr(44)
print chr(32)
print chr(87)
print chr(111)
print chr(114)
print chr(108)
print chr(100)
print chr(33)

多种语言：HQ9 +，H9 +，HQ9 ++，CHIQRSX9 +，HQ9 + B和HQ9 + 2D（1字节）

H

感谢@victor提供的语言列表。

OMGROFL

我非常喜欢深奥的语言。幸运的是，OMGROFL是字母数字：

lol iz 72
rofl lol
lol iz 101
rofl lol
lol iz 108
rofl lol
rofl lol
lool iz 111
rofl lool
loool iz 44
rofl loool
loool iz 32
rofl loool
loool iz 87
rofl loool
rofl lool
lool iz 114
rofl lool
rofl lol
lol iz 100
rofl lol
lol iz 33
rofl lol
stfu

的iz命令值设定为一个变量，在这种情况下lol，lool和loool作为变量...

的 rofl命令回显与变量中存储的数字等效的ASCII。

该stfu命令终止程序;）

科宝

   ID DIVISION 
   DATA DIVISION 
   01  HELLOWORLDBINARY 
       05  HE                       COMP    PIC 9999 
       05  LL                       COMP    PIC 9999 
       05  OCOMMA                   COMP    PIC 9999 
       05  SPACEW                   COMP    PIC 9999 
       05  ORTEXT                   COMP    PIC 9999 
       05  LD                       COMP    PIC 9999 
       05  EXCLAMATION              COMP    PIC 9999 
   01  FILLER REDEFINES HELLOWORLDBINARY 
       05  HELLOWORLDTEXT                   PIC XXXXXXXXXXXXX
       05  FILLER                           PIC X 
   PROCEDURE DIVISION 
       MOVE 51333                   TO HE 
       MOVE 37779                   TO LL 
       MOVE 38507                   TO OCOMMA 
       MOVE 16614                   TO SPACEW 
       MOVE 38553                   TO ORTEXT 
       MOVE 37764                   TO LD 
       MOVE 23104                   TO EXCLAMATION 
       DISPLAY HELLOWORLDTEXT 
       GOBACK 

需要进行一些更改才能仅成为真正的字母数字源。

可以删除PROGRAM-ID。您将获得一个生成的程序名称（请参阅消息）。

可以删除WORKING-STORAGE。编译器再次抱怨。

由于这两行以前都缺少句号/句点，而现在由于完全缺少描述而不再相关，因此错误消息的数量与以前相同，并且仍然不影响程序的生成代码。

在将COMP-5更改为COMP时，不再允许使用VALUE子句，因为COMP 9999仅是四个十进制数字，而COMP-5是一个两字节的二进制数，具有所有可用的位值。

MOVE中的值是十进制值，十进制值给出二进制值，二进制值给出字符对。

即使COMP字段有四个数字，并且不允许VALUE子句包含四个以上的数字，但您可以在文字值的MOVE中使用更多的数字，而不会被截断……不要问我为什么。编译器选项DIAGTRUNC（已关闭）将为这些生成警告诊断。

编译器选项TRUNC（BIN）可以将COMP视为COMP-5，但是MOVE是另一种方式。

由于它是COBOL，因此输出必须为大写（一个谎言，但这只是为了好玩）。

HELLO WORLD!

好了，放宽了，现在产生：

Hello, World!

这是一个奇数个字符，需要做一些进一步的更改，因为此编译器无法使用奇数字节的二进制字段。看看那行13 Xs！它通常被写为X（13），但是可以像我展示的那样。

并且需要ORTEXT作为名称（或者，还是不需要OR），因为OR是编译器的保留字（当然，它意味着OR）。

这些是EBCDIC值，而不是ASCII，因为它在支持EBCDIC的Big Endian框上运行。

哦，COBOL需要很多句点/句号。我把它们排除在外（它们被禁止了），所以得到了很多编译信息。只是告诉编译器无论如何都要生成代码（没有消息与目标代码相关）。

即使没有DIAGTRUNC，消息现在也可以达到17 ...

  1  IGYDS1003-E   A "PROGRAM-ID" paragraph was not found. 
  Program-name "CBLNAM01" was assumed. 

  2  IGYDS1082-E   A period was required.  A period was assumed 
  before "DATA". 

  3  IGYDS1082-E   A period was required.  A period was assumed 
  before "01". 

                   Same message on line:     11 

  3  IGYDS1040-E   A data item was found in the "DATA DIVISION" 
                   before a section header was encountered. 
                   "WORKING-STORAGE SECTION" was assumed. 

  4  IGYDS1082-E   A period was required.  A period was assumed 
  before "05". 

                   Same message on line:      5      6      7      8
                   9     10     12     13 

 14  IGYDS1082-E   A period was required.  A period was assumed 
 before "PROCEDURE". 

 15  IGYPS2145-E   A period was required.  A period was assumed 
 before "MOVE". 

 23  IGYSC1082-E   A period was required.  A period was assumed 
 before "END OF PROGRAM". 

Ruby（仅使用数字和空格）

putc 72
putc 101
putc 108
putc 108
putc 111
putc 44
putc 32
putc 87
putc 111
putc 114
putc 108
putc 100
putc 33

输出： Hello, World!

Java脚本

with (function SGVsbG8sIFdvcmxkIQ(){}) atob(name)

使用浏览器的控制台进行测试。

的JavaScript

with (String) with ([]) {
    push(fromCharCode(72))
    push(fromCharCode(101))
    push(fromCharCode(108))
    push(fromCharCode(108))
    push(fromCharCode(111))
    push(fromCharCode(44))
    push(fromCharCode(32))
    push(fromCharCode(87))
    push(fromCharCode(111))
    push(fromCharCode(114))
    push(fromCharCode(108))
    push(fromCharCode(100))
    push(fromCharCode(33))
    alert(join([]))
}

费尔南多

h E R
e I S
h E
l L O
w O
r L
d U S
i N G
o N L
y L E
t T E
r S

H e L L o W O R
L d h E L l O w
O r l D h e L L
O w o R l d H E
L l o W o r l d
H E l L o w O R
L D h E L L O W
O r L d H e l l
O w o R l d h e
L l o w O R l D
H e l L o w O R
L d h E L l O W
O R l D H E L l
O w O
r L d

Rebol

仅字母数字的解决方案：

prin quote Hello prin add space 12 prin space prin quote World print add space 1

上面是使用Rebmu博士的出色建议add space 1（产生!）来更新所有角色的更新。

以下是原始版本：

prin quote Hello prin pick mold system 264 prin space prin quote World print pick mold system 12

带支架的短版：

print rejoin [quote Hello pick mold system 264 space quote World pick mold system 12] 

甚至带有花括号的更短版本：

print join {Hello} join pick mold system 264 join { World} pick mold system 12

括号和花括号最短的版本：

print rejoin [{Hello} pick mold system 264 { World} pick mold system 12]

Rebol使用花括号{}进行多行引用。因此，在规则更改下完全有效，但不能像上面我的前两个答案那样全神贯注（IMHO）。

注意 打印!很痛苦！

Rebol允许并定期将标点符号用于函数名称和数据类型。因此，根据规则，不允许to-char 33或to char! 33不允许选择类似的选项（即使这些标点符号不是运算符本身）。

幸运的是，我通过将Rebol系统对象make object! [...]转换为字符串和樱桃来找到了一种轻松的方法!从中它:)

更新：现在，樱桃还从系统对象中的许可证文本中选择了逗号。

C

仅使用字母数字字符，空格和花括号{}，方括号[]和括号（）。

main()
{
        if(printf((long long []){0x202c6f6c6c6548}))
                if(printf((long long []){0x21646c726f57})){}
}

printf（）接受一个char *作为参数，但是由于我们不能使用quotes（“），所以我将字符串转换为一个长整型数组。这里看到的值是ASCII字符串，采用小尾数（0x48 = H，0x65 = e，0x6c = l，依此类推），我将其类型转换为long long []，因为这样我可以传递8字节的参数，因此仅使用两个printf（）调用，而不是四个。

英国广播公司

bbcbasic.co.uk上的仿真器

从我的LOGO答案中拆分。

简单的方法

右边的数字只是ASCII码。这与打印相同。如果允许使用逗号，则可以在一行（VDU 72,101,108,etc.）内进行

   10 VDU 72
   20 VDU 101
   30 VDU 108
   40 VDU 108
   50 VDU 111
   55 VDU 44
   60 VDU 32
   70 VDU 87
   80 VDU 111
   90 VDU 114
  100 VDU 108
  110 VDU 100
  120 VDU 33

更具创意的方式

    5 MODE 6
   10 READ B
   12 WHILE B
   15   PROC1(B)
   16   PRINT
   17   READ B
   18 ENDWHILE
   20 END

REM procedure prints first square on line, 
REM then calls itself recursively with A DIV 2 to print the next
REM VDU 17 tell VDU controller we want to change colour
REM Next line changes background colour. 
REM Then following line VDU 32 prints a space in that background colour.

  110 DEFPROC1(A)
  115 VDU 17
  120 IF A AND 1 THEN VDU VPOS DIV 6 EOR 133 ELSE VDU 128
  125 VDU 32
  130 IF A THEN PROC1(A DIV2)
  140 ENDPROC

REM binary bitmap data for each row, least significant at left
  150 DATA 463221
  160 DATA 332053
  170 DATA 332151
  180 DATA 332053
  190 DATA 2586485
  200 DATA 1048576
  210 DATA 4395895
  220 DATA 4527447
  230 DATA 4526935
  240 DATA 333143
  250 DATA 4420981
  260 DATA 0

Mathematica

Unprotect[Times]
ClearAll[Times]
Print[Hello FromCharacterCode[44] world FromCharacterCode[33]]

直流电

DC几乎是完成这项工作的理想工具。

5735816763073854918203775149089P

DCs P-command从堆栈中弹出一个数字，并将其原始计算机表示形式输出到STDIO。视作5735816763073854918203775149089 = 0x48656C6C6F2C20576F726C6421，0x21, 0x64, 0x6C... = 'H', 'e', 'l'...以小端架构表示，它输出Hello, World!。

JavaScript！

他们说这不可能完成……没有赋值运算符，没有连接器，没有引号！啊！

不要害怕...因为力量是with你...

function w(x){
    with(document){
        with(String){
            write(fromCharCode(x))
        }
    }
}
w(72)
w(101)
w(108)
w(108)
w(111)
w(44)
w(32)
w(87)
w(111)
w(114)
w(108)
w(100)
w(33)

Output (on browser screen): Hello, World!

Java脚本

更新：通过引入World函数也设法削减了很多字符。

另一个写入console.log的Javascript解决方案：

function World() { with (World) return name }
function Hello() {}
with (console)
with (String)
with (Hello)
with (name)
with (concat(fromCharCode(44)))
with (concat(fromCharCode(32)))
with (concat(World()))
log(concat(fromCharCode(33)))

受此条目启发。

首先，我定义名为Hello和World的函数。稍后将使用它。

然后，我开始我的嵌套withs链。该with (console)和with (String)使用，这样我以后可以调用console.log和String.fromCharCode不使用点。

现在的计划是Hello, World!通过滥用嵌套withs 来构建字符串。每次我调用concat（）时，结果字符串将是下一个with块中的上下文。我"Hello"通过访问name该Hello函数的属性来快速获得一条捷径。然后，使用来连接逗号和空格字符String.fromCharCode。

下一个技巧是获取"World"字符串的一部分。Hello由于无法调用World.name，因此无法使用与获取方法相同的方法。相反，我将该逻辑放入World方法中，然后调用它。

最后，我附加最后的感叹号，然后将结果直接发送到log函数，该函数当然是console.log。

佩尔

在现代的Perl（5.10或更高版本）中：

print q{Hello} and print chr 44 and print q{ World} and say chr 33

在较旧的Perl中：

print q{Hello} and print chr 44 and print q{ World} and print chr 33 and print chr 10

上面的两个解决方案都使用Perl q类似于报价的运算符，并允许使用选择性定界符来引用字符串（例如）。 q{} q[] q() q//

此解决方案需要更改规则，允许使用花括号，方括号或括号。因此，虽然完全有效，但我认为mniipPerl的最佳答案更多是符合规则的实质（+1）。

但是mniip我的解决方案可以像这样写：

print q xHellox and print chr 44 and print q x Worldx and say chr 33

而且，即使在眼睛上，它也确实起作用。

佩尔

print chr hex for qw z48 65 6c 6c 6f 2c 20 57 6f 72 6c 64 21z

蟒蛇：

import antigravity 

导致“你好，世界！” 出现在屏幕上。不相信我吗？自己试试吧！此外，这实际上并没有使用网络，而是打开了浏览器，可能会查找网站。

空格

好的，我们可以使用空格。它仅使用Space，Tab，LineFeed和忽略任何其他字符。

随着评论：S，T或L手段Space，Tab或LineFeed分别。

S S S T S S T   S S S L
T   L
S S S S S T T   S S T   S T L
T   L
S S S S S T T   S T T   S S L
T   L
S S S S S T T   S T T   S S L
T   L
S S S S S T T   S T T   T   T   L
T   L
S S S S S T S T T   S S L
T   L
S S S S S T S S S S S L
T   L
S S S S S T T   T   S T T   T   L
T   L
S S S S S T T   S T T   T   T   L
T   L
S S S S S T T   T   S S T   S L
T   L
S S S S S T T   S T T   S S L
T   L
S S S S S T T   S S T   S S L
T   L
S S S S S T S S S S T   L
T   L
S S L
L
L

高亮显示：http : //en.wikipedia.org/wiki/Whitespace_(programming_language)#Sample_code

dc，（高尔夫球手为26个字节）

[]现在允许使用空格和方括号：

[Hello]n44P[ World]n33P[]p

输出：

$ dc <<< "[Hello]n44P[ World]n33P[]p"
Hello, World!
$ 

雷布姆，46个字符

pnUPPqHELLO01pnADsp12pnSPpnUPPqWORLD01pnADsp01

@dragetun在Rebol中的解决方案 非常相似（因为Rebmu是Rebol / Red教学工具，是一种“方言”，旨在通过在Code Golf上摇摆来引起人们对语言的关注。：-P）

但是，为了得到缺少的字符，我做了一些更明显的事情。我只是增加了空间，而不是浏览系统字符串。您可以添加空格1来获取字符文字＃“！”。和增加空间12以获取字符文字＃“，”。

如果运行此命令，我们可以看到它被“清除”：

>> rebmu/debug/stats "pnUPPqHELLO01pnADsp12pnSPpnUPPqWORLD01prADsp01"
Original Rebmu string was: 46 characters.
Rebmu as mushed Rebol block molds to: 46 characters.
Unmushed Rebmu molds to: 62 characters.
Executing: [pn upp q hello 1 pn ad sp 12 pn sp pn upp q world 1 pr ad sp 1]
Hello, World!

这是相当逻辑的：

; print with no newline the result of doing an uppercase/part
; on the quoting of the symbolic word hello, of only the first
; N characters (where N is 1)
pn upp q hello 1

; print the character you get when you add 12 to the space
; character literal, a.k.a. comma...again no newline
pn ad sp 12

; print a space, no newline
pn sp

; do the same trick of printing the quoted word hello with the
; first letter converted to uppercase
pn upp q world 1

; print the character you get when you add 1 to the space
; character literal, a.k.a. exclamation point...with newline now
pr ad sp 1

T-SQL，52岁

嗯，这样更好！直接二进制转换，仅52个字符。

SELECT CAST(0x48656C6C6F2C20576F726C6421 AS VARCHAR)

先前...

如果我们可以使用=和+（在msdb中查找标准内置数据并使用该数据构建可执行EXEC的查询字符串），则有一个更聪明，更完善的解决方案将起作用。

但是由于我们做不到，所以您会得到这种天真的方法：

SELECT CHAR(72)SELECT CHAR(101)SELECT CHAR(108)SELECT CHAR(108)SELECT CHAR(111)SELECT CHAR(44)SELECT CHAR(32)SELECT CHAR(87)SELECT CHAR(111)SELECT CHAR(114)SELECT CHAR(108)SELECT CHAR(100)SELECT CHAR(33)

蟒蛇：

PFFF，谁需要字母数字的数字部分？

from string import lowercase
from string import uppercase
from string import punctuation
print uppercase[len(str([[[len(str())]]]))]
print lowercase[len(str([[]]))]
print lowercase[len(str([[[[[len(str())]]]]]))]
print lowercase[len(str([[[[[len(str())]]]]]))]
print lowercase[len(str([[[[[[[]]]]]]]))]
print punctuation[len(str([[[[[len(str())]]]]]))]
print
print uppercase[len(str([[[[[[[[[[[]]]]]]]]]]]))]
print lowercase[len(str([[[[[[[]]]]]]]))]
print lowercase[len(str([[[[[[[[len(str())]]]]]]]]))]
print lowercase[len(str([[[[[len(str())]]]]]))]
print lowercase[len(str([len(str())]))]
print punctuation[len(str())]

这取决于语言环境，因此您的里程可能会有所不同。但是，如果您确实要复制此结果，则可以使用以下内容代替import语句：

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

（这不是我提交的内容的一部分，只是分享我的本地人的可再生性）

J-73字符

它可以做到的，毕竟！

72 101 108 108 111 44 32 87 111 114 108 100 33{do 1 8{show 0 def 0
take
)

关于J的事情就是这样。大多数原语都是ASCII标点符号，后跟最多两个点或冒号。那些不是由标点符号组成的图元是一个字母数字字符，后跟两个点或冒号。因此，除了，我们都不允许使用{ } [ ]。[并且]是身份动词，因此没有用。

幸运的是，可以为{数组建立索引，因此，如果我们有一个包含每个ASCII字符（a.称为字母）的字符串，则可以通过其ASCII码点将字母拉出。我们还有一种备用的方式来制作琴弦，0 : 0然后做东西，然后做一个孤独的人); 在标准库中带有别名的冒号def。

然后在标准库show中有一个动词，如果您将动词的名称作为字符串传递给您，它会为您提供动词的内部表示。还有另一个动词，do它将评估字符串。因此，如果我们可以a.从任何此类表示中提取，则可以对其进行评估并提取Hello, World!。

我们的救主进来的形式take，一个别名{.有一个a在它的名字。show'take'将返回take=: {.，因此我们有了a.解决方案。

我们可以{使用pick标准库中的等效项来摆脱它，但是最后的避免是无法避免的。