你好世界0.0！

78

迪尔伯特很棒
资料来源：Dilbert，1992年9月8日

我希望在经典的“ Hello World！”上添加新的变化。程序。

编写输出以下内容的程序Hello World!：

  • 字符串/字符文字
  • 数字（任何基数）
  • 预置的函数返回“ Hello World！”
  • RegEx文字

除“ O” †和0以外。

†“ O”大写，“ o”不可接受。

code-golf  hello-world  restricted-source 
— zzzzBov
source
4
请同时使用[code-golf]和[code-challenge]中的一种。这些标签的作用是帮助人们找到他们要使用的规则的问题。基本上，该网站上的每个问题都应该是某种形式的游戏。
— dmckee，2011年
4
-1我们已经迷惑了Hello World，我认为这个挑战太相似了。如果我不是mod的话，我会投“接近重复”的票。
— 克里斯·杰斯特·杨
2
@zzzzBov：我认为这与“ hello world”主题中的另一个问题没有什么不同；一个不同的主题会更好。但那只是我的个人意见。
— 克里斯·杰斯特·杨
1
我认为这是一种很好的打法-比以前的打法好。
— MtnViewMark 2011年
2
有些人似乎认为这"O"*意味着它们可以具有任意数量的O（包括零）的字符串文字。我不认为这是故意的。请澄清。
— Timwi

Answers:

83

Windows PowerShell，太多了

是的，的确如此，早在那天我们不得不（几乎完全）使用零来写一个“ Hello world”……

&{-join[char[]]($args|% Length)} `
O00000000000000000000000000000000000000000000000000000000000000000000000 `
O0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O0000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000

更严重的是：

Windows PowerShell，25

Write-Host Hello World!

没有字符串文字。将Hello World!在那里恰好被解析为，因为PowerShell的字符串在参数解析模式存在。

— 乔伊
source
2
那是真的吗？O_o
— Josh
1
我在互联网上搜索了一些示例或历史记录。太奇怪了 您能提供任何链接吗？
— Caleb Jares 2011年
1
“早些时候”。:)千禧一代让我me不休
哦。一元。我知道了。
— 马修·卢
86

C，327个字符

#define O(O)-~O
#define OO(o)O(O(o))
#define Oo(o)OO(OO(o))
#define oO(o)Oo(Oo(o))
#define oo(o)oO(oO(o))
#define O0 putchar
main() {
    O0(OO(oO(!O0(~O(Oo(OO(-O0(~O(Oo(-O0(O(OO(O0(oo(oO(O0(O(oo(oO(OO(Oo(oo(oO(
    O0(oo(oo(!O0(O(OO(O0(O0(O(OO(Oo(O0(O(Oo(oo(oO(O0(oo(oo(oO(oo(oo(0))))))))
    ))))))))))))))))))))))))))))))))))))));
}

奇怪的是，它在预处理后不会失去其美感：

main() {
putchar(-~-~-~-~-~-~-~-~-~-~!putchar(~-~-~-~-~-~-~-~-putchar(~-~-~-~-~-~-
putchar(-~-~-~putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-~-~-~-~-~-~-~-~-~-~-~-~-~!putchar(-~-~-~putchar(putchar(-~-~-~-~-~-~-~putchar
(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(-~-~-~-~-~-
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0))))))))))));
}
— 乌戈伦
source
2
太棒了 缺少！。
— 马克·里德
1
这是真实的艺术！
— Askaga 2014年
我觉得可以使用更多的预处理器来缩短机身。不确定整个代码是否会带来好处。
— Zwei
@Zwei，可以缩短它。我不花力气找到最佳的宏集。
— ugoren '16
您为什么不在CLANG #define中包含括号？会节省几个字节，不是吗？编辑：没关系，只是尝试过，现在我明白了为什么这行不通啊哈
— 阿尔伯特·伦肖
52

BrainFuck，102111 个字符

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

符合所有规则。

幸得丹尼尔Cristofani。

— 凯文·布朗
source
1
我无法决定规则是否也应说明0 and/or "O" must be used。对于BrainFuck和golfscript来说，这有点小意思，但是他们面对这一挑战并不困难。
— zzzzBov 2011年
34
@zzzzBov：如果必须使用它们，那么Brainfuck代码将仅包含它们。但是，它们根本不影响程序。
— Joey
38

C，182字节

#define decode(c,o,d,e,g,O,l,f) e##c##d##o
#define HelloWorld decode(a,n,i,m,a,t,e,d)
#define Puzzles(flog) #flog
#define CodeGolf Puzzles(Hello World!)
HelloWorld(){puts(CodeGolf);}
— fR0DDY
source
1
+1，大声笑，您仍在使用令牌粘贴运算符！好朋友:-)
— Quixotic
35

C程序-45

（作弊）

词汇上，这不使用任何字符串文字或正则表达式文字。它利用了C预处理程序的字符串化功能。 s(x)是将其参数转换为字符串的宏。

#define s(x)#x
main(){puts(s(Hello World!));}
— 乔伊·亚当斯（Joey Adams）
source
3
对于“词汇上”的一个非常方便的概念:)但是脸颊FTW！
— JB
24

Haskell-143个字符

o%y=o.o.o$y;o&y=(o%)%y;o!y=o$o$(o%)&y
r=succ;w=pred;a=r%y;e=r$w&l;l=r!'O';o=r e;u=(w&)&a;y=r%l
main=putStrLn[w!o,o,l,l,y,w u,w$r&'O',y,a,l,e,u]

好的，那真是毛茸茸！

没有数字，没有数字运算，为娱乐而重命名的变量。

一些说明可能是不错的：

  • o%y，o&y和o!y每个应用函数o以y分别为3，图9和29倍：多次。29？！？！是的，29岁！
  • r和w是下一个和上一个字符，使用上述高阶函数进行应用时，可以从中获取所需的所有字符'O'。

所需的跳跃顺序为：

'O' +29    -> 'l'
'O'  +9 -1 -> 'W'
'l'  -9 +1 -> 'd'
'l'  +3    -> 'o'
'd'  +1    -> 'e'
'o'  +3    -> 'r'
'e' -29    -> 'H'
'r' -81    -> '!'
'!'  -1    -> ' '
  • 编辑：（134-> 144）忘了输出感叹号，叹息。
  • 编辑：（144 - > 143）删除了一个不必要的$，改名#以!用于拥抱。
— MtnViewMark
source
1
哦？oo ....
— Joey Adams
— nyuszika7h 2011年
@ Nyuszika7H这是因为此服务默认情况下会打开某些编译器选项。它应与普通GHC一起编译。
— FUZxxl 2011年
@ Nyuszika7H它与GHC正常工作。问题在于该服务从2006年开始使用Hugs。似乎有两件事是Hugs无法处理的：1）使用'＃'作为运算符。更改为“！” 使它工作。2）拥抱如何实现单态性限制的定义r=succ并w=pred与之冲突。更改为r x=succ x并w x=pred x使其生效（需要4个字符）。这些似乎是拥抱的问题。
— MtnViewMark'3
@Community编辑后，它仍然有效吗？
— 2014年
22

一元，10 197 1137672766964589547169964037018563746793726105983919528073581559828字节

令我感到惊讶的是，还没有人这样做。

在这里发布的时间太长了，但它是1137672766964589547169964037018563746793726105983919528073581559828零。

或者，更容易阅读：〜10 67个零。

感谢@dzaima节省了10197 个字节

— Beta衰变
source
2
当我读到“我曾经只用零写过一个完整的数据库”时，我的第一个念头是“他必须在一元中完成它”。+1是使漫画完全正常工作的唯一答案
— Cyoce
21

Mathematica 12个字符

只有符号，没有字符串。

Hello World!

！是阶乘运算符，但由于未定义符号Hello和World，因此返回的输入不变。

如果我们稍微修改程序： 

Hello=2;
World=3;
Hello World!

然后打印12（2 * 3！）

— 贝利萨留博士
source
16

I386组件（Linux操作系统，GCC语法），440 442 435

今天是我的集会日，在那之后我会吃了一会儿。 我允许自己编号128，请参见下面的程序以讨论原因。 没什么特别的：我只是在编码“ Hello World！” 作为汇编操作码，在没有数字常量的情况下是有意义的，其余部分都用算术填充。

#define M mov
M $0,%ecx;inc %cx;M %ecx,%ebx;inc %cx;M %ecx,%eax;add %ax,%ax
M %ecx,%edx;shl %cl,%dx;M (e),%ch;add %dl,%ch;dec %ch;M %ch,(l)
M %ch,(j);M %ch,(z);M $0,%ch;shl %cl,%edx;M %dl,(s);inc %dl
M %dl,(b);M (o),%dl;M %dl,(u);add %al,%dl;dec %dl;M %dl,(r)
M $m,%ecx;M $n,%edx;int $c;M %ebx,%eax;M $0,%ebx;int $c
.data
m:dec %eax;e:gs;l:es;j:es;o:outsl (%esi),(%dx)
s:es;push %edi;u:es;r:es;z:es;fs;b:es;n=.-m
t=(n+n)/n;c=t<<(t*t+t)

（与组装gcc -nostartfiles hello.S -o hello，可能-m32取决于您的拱门）

为什么公差为128？我需要系统调用才能真正显示任何内容；Linux系统调用位于INT 80h（十进制128）上；INT的唯一操作数格式是立即数，因此除了常量（对于代码而言）之外，不可能有其他任何内容。我可以（在我清醒之后）尝试将其表示为代码中其他符号常量的函数，可能是n，但是这样做却很无聊，没有太多收益。我阅读了数字上的约束条件，以防止ASCII编码，但这绝对不是我在这里所做的，因此我很无辜地提交了此信息。（FWIW，我也尝试过自动修改代码，但这很容易出错） 现在也没有128个了。代码很纯正！

  • 重新格式化Edit1以保存行；删除了数字1（没人注意到吗？！）
  • mov用CPP宏压缩的Edit2；消除了剩余的128个。
— JB
source
6
这就是真正的男人程序。
— 2014年
14

Javascript-305

有点长，但我喜欢使用的方法。

O=0;O++;O=O.toString();alert([O+0+0+O+0+0+0,0+O+O+0+0+O+0+O,O+O+0+O+O+0+0,O+O+0+O+O+0+0,O+O+0+O+O+O+O,O+0+0+0+0+0,O+0+O+0+O+O+O,O+O+0+O+O+O+O, O+O+O+0+0+O+0,O+O+0+O+O+0+0,O+O+0+0+O+0+0,O+0+0+0+0+O].map(function(e){O=0;O++;O++;return String.fromCharCode(parseInt(e,O))}).reduce(function (a,b){return a+b}))
— david4dev
source
我喜欢。将函数参数设置为OO，会更好OOO，但当然会使其更长。
— zzzzBov 2011年
非常好。'，new String（）'是否需要在末尾出现？没有它似乎可以工作。
— 史蒂芬·佩雷尔森
3
啊，不，不是。有时候，我忘记了JavaType的弱类型。
— david4dev 2011年
您也不需要左0位（'0+'），并且空格和感叹号都有两个左0位。总共减少28个字符。
— 史蒂芬·佩雷尔森
10

C＃（131个字符）

141个字符 142个字符

enum X{Hello,World,A,B=A<<A<<A}class Y{static void Main(){var c=(char)X.B;System.Console.Write(X.Hello.ToString()+c+++X.World+c);}}

可读性：

// Define some constants (B = 32)
enum X { Hello, World, A, B = A << A << A }
class Y
{
    static void Main()
    {
        // Generate the space (character #32)
        var c = (char) X.B;

        // Remember that “!” is character #33
        System.Console.Write(X.Hello.ToString() + c++ + X.World + c);
    }
}
— Timwi
source
2
这是扭曲和美好。我喜欢它。
— jcolebrand
+1种生成特定数字的好方法。要记住这一点！
— Igby Largeman
LINQPad程序，102个字符：enum X{Hello,World,A,B=A<<A<<A}void Main(){var c=(char)X.B;(X.Hello.ToString()+c+++X.World+c).Dump();}
— 2014年
.ToString()-> +""节省了一些时间
— Firo
2
@Firo：...并且违反了规则。（不允许使用字符串文字。）
— Timwi，2014年
8

JavaScript的88

t=!0<<-~-~-~-~!0
r=[]
for(i in{Hello:"O",World:0})r+=i+String.fromCharCode(t++)
alert(r)

99

非常感谢@Timwi的建议

删除三元运算符：

o={Hello:"O",World:0}
t=!0<<-~-~-~-~!0
c=String.fromCharCode
r=c(0)
for(i in o)r+=i+c(t++)
alert(r)

103
别名String.fromCharCode

o={Hello:"O",World:0}
t=!0<<-~-~-~-~!0
c=String.fromCharCode
for(i in o)o[i]?r=i+c(t):alert(r+i+c(++t))

117将
if-else切换为三元运算符

o={Hello:"O",World:0},t=!0<<-~-~-~-~!0
for(i in o)o[i]?r=i+String.fromCharCode(t):alert(r+i+String.fromCharCode(++t))

125
我保留"O"在程序中保留“ O”的权利。

o={Hello:"O",World:0},t=!0<<-~-~-~-~!0
for(i in o)if(o[i])r=i+String.fromCharCode(t)
else alert(r+i+String.fromCharCode(++t))

133

o={Hello:"O",World:0},t=!0<<(!0+!0<<!0)+!0
for(i in o)if(o[i])r=i+String.fromCharCode(t)
else r+=i+String.fromCharCode(t+!0)
alert(r)
— zzzzBov
source
@Joey，这基本上就是重点。
— zzzzBov 2011年
@Joey，我在codegolf meta上读到，一个人应避免在一段时间内回答自己的问题，以鼓励其他人尝试各种不同的方法。我的计划是在一两天内取消注释。
— zzzzBov 2011年
@Joey当时不是在我自己的机器上工作，所以当我可以在评论中发布答案时，我不希望通过电子邮件将答案发送给自己。
— zzzzBov 2011年
@乔伊：“只有五个”是错误的。任何人都可以提出修改建议。只需单击“链接”和“标志”之间的“编辑”，即可看到代码。
— 约翰，
@zzz：“基本上就是重点”， 任何人仍然可以看到它。任何人都可以通过单击“链接”和“标志”之间的“编辑”来建议编辑，这将弹出编辑对话框，并显示您的代码。
— 约翰，
7

GolfScript，63个字符

[0))):O.)?O.*-.O.?+)).O.*+((..O+.O(.O+?.O-O*@.O+O.+$.O.*-).O/]+

什么，还没有GolfScript条目？

此代码使用单个数字文字0和一个名为的变量O（用于存储number 3）。其他一切都是算术和堆栈操作。字符串Hello World!是由其ASCII码逐个字符构成的。

运作方式如下：

[             # insert start-of-array marker
  0))):O      # increment 0 thrice to get 3, and save it in the variable O
  .)?O.*-     # calculate 3^(3+1) - 3*3 = 81 - 9 = 72 = "H" 
  .O.?+))     # calculate 72 + 3^3 + 1 + 1 = 72 + 27 + 2 = 101 = "e"
  .O.*+((     # calculate 101 + 3*3 - 1 - 1 = 101 + 9 - 2 = 108 = "l"
  .           # ...and duplicate it for another "l"
  .O+         # calculate 108 + 3 = 111 = "o"
  .           # ...and duplicate it for later use
  O(.O+?      # calculate (3-1)^(3-1+3) = 2^5 = 32 = " "
  .O-O*       # calculate (32 - 3) * 3 = 29 * 3 = 87 = "W"
  @           # pull the second 111 = "o" to the top of the stack
  .O+         # calculate 111 + 3 = 114 = "r"
  O.+$        # copy the (3+3 = 6)th last element on the stack, 108 = "l", to top
  .O.*-)      # calculate 108 - (3*3) + 1 = 108 - 9 + 1 = 100 = "d"
  .O/         # calculate int(100 / 3) = 33 = "!"
]             # collect everything after the [ into an array
+             # stringify the array by appending it to the input string
— 伊玛里·卡洛宁
source
7

Brainfuck，111个字节

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

算法说明

Increment cell 0 to 10 (it will be loop counter)
Repeat 10 times ; will stop at cell 0
  Increment cell 1 to 7
  Increment cell 2 to 10
  Increment cell 3 to 3
  Increment cell 4 to 1
Increment cell 1 by 2 and output it ; Thus, output ASCII 72 'H'
etc. for all symbols in 'Hello World!'

较长版本，无循环，389字节：

+++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++.+++++++++++++++++
++++++++++++.+++++++..+++.-------------------
---------------------------------------------
---------------.+++++++++++++++++++++++++++++
++++++++++++++++++++++++++.++++++++++++++++++
++++++.+++.------.--------.------------------
---------------------------------------------
----.-----------------------.
— 麦可
source
这是一个代码难题，重点是制作尽可能短的程序。其中一部分涉及发布代码的长度。
— zzzzBov 2012年
5

Lua 144 97 86字符

基于表键也是字符串的事实以及#Hello == #World == 32 == string.byte'\ n'的事实，采用了另一种方法

e=#"O"t=e+e for k,v in pairs{Hello=0,World=e}do T=t^#k io.write(k,string.char(T+v))end

145个字符的溶液

  • 除“ O”或0外，没有其他字符串
  • 没有正则表达式
  • 没有预先建立的功能

是否对字节进行了增量编码，然后是一些素数等：)

高尔夫球版：

e=#"O"d=e+e t=d+e v=d+t z=v+t T=t^d*d^t n=0 for l,m in pairs{T,T/t-z,z,0,d,-T-z,z*z+t*d,T/d,d,-d*t,-t^d,-T+v}do n=n+m io.write(string.char(n))end

评论：

-- without numbers, strings, regex
-- except "O" and 0
e=#"0"
t=e+e --2
d=t+e -- 3
v=d+t -- 5
z=v+t -- 7
n=0
T=t^d*d^t -- 72 = 2^3+3^2
for l,m in pairs{T, --72
T/t-z, -- 29 = 72/2-7
z, --7
0, -- 0
d, -- 3
-T-z, -- -79 = -72 - 7
z*z+t*d, -- 55 = 7*7 + 2*3
T/d, -- 24 = 72/3
d, -- 3
-d*t, -- -6
-t^d, -- -8
-T+v -- -67 = -72+5
} do
    n=n+q[k]
    io.write(string.char(n))
end

编辑：更改了多个O字符串，并找到了更多的优化方法。

— jpjacobs
source
“ O” *-我认为*用于脚注，而不是“任意数量的O
— RomanSt 2011年
好吧，regex'ing是我自然要做的：p。可以以5个或3个额外的字符分别用于第一和第二溶液中的成本更换
— jpjacobs
但是无论如何，我会把它们编辑掉，谢谢大家的注意
— jpjacobs 2011年
表构造函数中的Hello和World仍然是字符串文字-只是一个语法糖。
— Oleg V. Volkov 2015年
5

蟒蛇（126130）

O=ord("O")
N=O/O
T=N+N
R=N+T
E=T**R
E<<T
print'O'[0].join(chr(c+O)for c in[N-E,E*R-T,_-R,_-R,_,N-_-E-E,E,_,_+R,_-R,E*R-R,T-_-E-E])
— 华隆潭
source
''不允许使用文字。
— 2011年
1
@romkyns：非常正确，已修复。
— Hoa Long Tam
5
不固定（错误的输出）。您可能正在考虑[:0]。
— WolframH 2013年
5

J，250

oo=:#a.
o0=:<.o.^0
o0o=:%:%:%:oo
ooo=:p:^:(-*oo)
o=:<.(^^^0)*(^^0)*(^^0)
o00=:o,~(,[)o0(**(**[))o0o
oo0=:*/p:(!0),>:p:!0
echo u:(o0(**(**]))o0o),(ooo ooo ooo(o.o.^^^0)*oo),o00,(+:%:oo),(oo0-~!p:>:>:0),o,(<.-:o.o.^o.^0),(>:p:(]^])#o00),(*:#0,#:oo),oo0

我对此玩得太开心了，我学到了更多的J来启动。同样，这ooo ooo ooo可能是我编写过的最愚蠢的代码。

— 杰西·米利坎（Jesse Millikan）
source
5

带半块的QR （169） 121个字符

通过使用UTF-8 Half-blocks字符使用QR码：

▗▄▄▄▗▄▖▗▄▄▄  
▐▗▄▐▝█▙▐▗▄▐  
▐▐█▐▝▄ ▐▐█▐  
▐▄▄▟▗▗▗▐▄▄▟  
▗▗▖▄▞▝ ▗ ▖▄  
 ▟▜ Code ▀▟  
 ▙▀ Golf ▘▚  
▗▄▄▄▐▗▘▟▙▝▝  
▐▗▄▐▝▀▛▘▘█▖  
▐▐█▐▐▖▐▝▖▜▘  
▐▄▄▟▗ ▌█▛▗▝  3

不幸的是，这不会在那里很好地呈现。有一些带有适当样式表的代码段，但是..不！这里提供的语言不是 HTML！这里显示的语言是QR码！（此处仅使用HTML和CSS来解决表示错误！）

显示代码段

带半块的QR（169）

  ▛▀▀▌▚▝▐▀▌▛▀▀▌
  ▌█▌▌▖▞▚▚▘▌█▌▌
  ▌▀▘▌ ▚▛▞ ▌▀▘▌
  ▀▀▀▘▚▌▙▘▌▀▀▀▘
  ▄▙▛▚▜▀▄▀█▖▝▄▌
  ▖▄▄▘▖▄▄▄▟▗ ▀▘
  ▜Code  golf!▌
  ▚▟▘▘▝▙▛▚▐▀▖▜▘
  ▘▘ ▀▛▗▚▗▛▀▌▄ 
  ▛▀▀▌▟▌▜▖▌▘█▐▘
  ▌█▌▌▘█▌▟█▜▙▐ 
  ▌▀▘▌▚▌▌█▗▝▌▚▘
  ▀▀▀▘ ▝▘▘▀▀▀▀▘

从概念上讲，这看起来像：

QR：世界你好！

— 豪里
source
使用您的智能手机或zbar在linux下查看。（样品：xwd | xwdtopnm | zbarimg /dev/stdin）
— F. Hauri
这不是Code golf!字符文字吗？
— ugoren 2014年
2
实际上，我认为这个答案虽然很有创意，但由于它不是程序，因此不符合要求。QR是一种编码数据的方法，而不是一种编程语言。
— ugoren 2014年
1
还有类似的语言postscript，svg或者已经在这里使用的其他演示语言呢？编码的方式还是一种语言 ……我想！
— F. Hauri 2014年
1
我使用HTML（减去JS）作为非语言的示例。QR也是如此。请参阅这些条件。
— ugoren 2015年
4

阶（357个 423 361字符）

不幸的是，这不是最短的答案，而是希望获得对'O'和的最多使用的加分。'0'

def h(){type t=scala.Char;def OO(c:t)={(c-('O'/'O')).toChar};def O(c:t)={OO(OO(OO(c)))};def O00(c:t)={(c+('O'/'O')).toChar};def O0(c:t)={O00(O00(O00(c)))};val l=O('O');val z=O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(0)))))))))));print(OO(O(O('O'))).toString+(OO(O(O(O('O')))).toString+l+l+'O'+OO(z)+O0(O0(O0(OO('O'))))+'O'+O0('O')+l+OO(OO(O(O(O('O')))))+z).toLowerCase)}

先前：

def h(){type t=scala.Char;print(OO(O(O('O'))).toString+(OO(O(O(O('O')))).toString+O('O')+O('O')+'O'+OO(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(0))))))))))))+O0(O0(O0(OO('O'))))+'O'+O0('O')+O('O')+OO(OO(O(O(O('O')))))+O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(0)))))))))))).toLowerCase);def OO[Char](c:t)={(c-('O'/'O')).toChar};def O[Char](c:t)={OO(OO(OO(c)))};def O00[Char](c:t)={(c+('O'/'O')).toChar};def O0[Char](c:t)={O00(O00(O00(c)))}}

旧（非法）版本：

def h(){type t=scala.Char;print(""+OO(O(O('O')))+(""+OO(O(O(O('O'))))+O('O')+O('O')+'O'+OO(O(O(O(O(O('0'))))))+O0(O0(O0(OO('O'))))+'O'+O0('O')+O('O')+OO(OO(O(O(O('O')))))+O(O(O(O(O('0')))))).toLowerCase);def O0[Char](c:t)={O00(O00(O00(c)))};def O[Char](c:t)={OO(OO(OO(c)))};def OO[Char](c:t)={(c-('O'/'O')).toChar};def O00[Char](c:t)={(c+('O'/'O')).toChar}}
— 加雷斯
source
我认为不允许使用空字符串（""）和包含字符零（'0'）的字符串/字符文字。仅字符串"O"（大写O）和数字0是。
— Timwi
臭虫 然后需要进行一些编辑...
— Gareth
4

C（或C ++）（正文部分：49）（作弊）

编译时，编译为名为的二进制文件Hello\ World\!，代码为：

#include <stdio.h>
#include <string.h>
int main(int i,char**a)
{
  int j=i+i,k=j<<j;puts(strrchr(*a,'O'-(k<<j))+i);
}

如果strrchr传入的程序名称包含完整路径，则该段是删除完整路径所必需的，并且也不必在。中传递任何参数。

典型的编译行可能是： gcc -o Hello\ World\! foo.c

— 尼姆
source
3

C ++，141， 146

第一次尝试其中的一种，可能还可以改善很多：

char o='O'/'O',T=o+o,X=T+o,f=T+X,t=f+f,F=t*f,h=F+F,l=h+t-T,O=l+X;
char c[]={F+t+t+T,h+o,l,l,O,o<<f,h-t-X,O,l+f+o,l,h,0};
cout<<c;

编辑：

从另一篇文章中窃取了划分技巧，简直不敢相信我没想到:(

— 洛伦VS
source
1
从技术上讲，您应该将整个工作程序包括在字符数中，包括诸如main，任何包含的库std::等之类的东西
— Wug 2012年
3

哈斯克尔-146

a:b:c:f:g:s:j:z=iterate(\x->x+x)$succ 0
y=[f+j,d+a,c+s+h,l,a+b+l,s,f-s+o,o,a+b+o,l,l-f,a+s]
[h,e,l,_,o,_,w,_,r,_,d,x]=y
main=putStrLn$map toEnum y

我认为模式匹配将使Haskell受益匪浅，特别是因为您可以像这样初始化两个的幂：

one:two:four:eight:sixteen:thirty_two:sixty_four:the_rest = iterate (*2) 1

但是，从MtnViewMark的Haskell答案（顺便说一句，应该得到许多赞誉）和其他答案可以看出，使用不仅仅是just +和可以实现更好的压缩-。

— 乔伊·亚当斯（Joey Adams）
source
3

Clojure-46个字符

(map print(butlast(rest(str'(Hello World!)))))

请注意，Hello和World!是符号，而不是任何种类的文字。

— 米克拉
source
3

C ++

/*
Hello World!
*/
#define CodeGolf(r) #r
#include<iostream>
using namespace std;
int main()
{
    char str[*"O"];
    freopen(__FILE__,CodeGolf(r),stdin);
    gets(str);gets(str);puts(str);
}
— fR0DDY
source
1
将100违反有关数字的规则。请用更有趣的东西代替它。
— 乔伊·亚当斯
@ joey-adams感谢您指出。改变了。
— fR0DDY 2011年
Line 7: error: ISO C++ forbids declaration of 'main' with no type
— 内森·奥斯曼
@ george-edison已更正。尽管它int在g ++上
— 不起作用
3

PHP – 49个字符

<?=Hello.chr(($a=-~-~-~0).~-$a).World.chr($a.$a);

更新日志：

  • （73 - > 86）忘了输出感叹号... 叹息
  • （86-> 57）使用单个变量递增
  • （57-> 51）更改为在0上使用按位运算符
  • （51-> 49）更多按位运算符
— nyuszika7h
source
1
可以肯定的是，由于进行了转换，这些常量将被视为字符串文字。
— 凯文·布朗
@ Bass5098感谢您的编辑！我批准了
— nyuszika7h 2011年
@ Bass5098不起作用，您需要具有32和33字符，而不是21和22。<?$a=-~-~-~0;echo Hello.chr($a.$a-1).World.chr($a.$a);可以，但是它是54个字符。
— zzzzBov 2011年
@zzzzBov我不知道最初如何清除编辑，并且一旦批准就忘记了将其回滚。
— 凯文·布朗
哎呀，我留在那儿了1。我要打破自己的规则了…… <?$a=-~-~-~0;echo Hello,chr($a.~-$a),World,chr($a.$a);我应该使用的仍然是54个字符。
— zzzzBov 2011年
3

蟒蛇，106

o=-~-~-~0
L=o+o
d,W=-~L,o**o
_=o*W
print str().join(chr(L+W+_-i)for i in[d*L,L+d,L,L,o,-~_,W,o,0,L,d+d,_])
— 地震
source
使用”（没有前面的空格）代替str（）
— aditsu
2
另外，非常好！:)顺便说一句，多重分配不会保存任何字符
— aiditsu
@aditsu：我不能，那是字符串文字。感谢您的意见。:)
— flornquake 2013年
哦，天哪，空字符串在我的脑海中并没有注册为字面量
— -aditsu
3

Perl，186个字节

@A=(0,0,0,0);@B=(@A,@A);@C=(@B,@B);@D=(@C,@C);@E=(@D,@D);@d=(@E,@D,@A);$l=[@d,@B];$o=[@$l,0,0,0];print(chr@$_)for[@E,@B],[@d,0],$l,$l,$o,\@D,[@E,@C,@A,0,0,0],$o,[@$o,0,0,0],$l,\@d,[@D,0]

每个字符都通过其序号打印，序号是数组的长度。通过字符数的二进制表示来优化数组的构造。

取消高尔夫：

@A = (0, 0, 0, 0);          # A = 2^2
@B = (@A, @A);              # B = 2^3
@C = (@B, @B);              # C = 2^4
@D = (@C, @C);              # D = 2^5
@E = (@D, @D);              # E = 2^6

# d = 100 = 0x64 = 1100100b
@d = (@E, @D, @A);          # d = 2^6 + 2^5 + 2^2 

# l = 108 = 0x6C = 1101100b
$l = [@d, @B];              # l = d + 2^3

# o = 111 = 0x6F = 1101111b
$o = [@$l, 0, 0, 0];        # o = l + 3

print (chr @$_) for
    [@E, @B],              # "H"    H  =  72 = 0x48 = 1001000b = 2^6 + 2^3
    [@d, 0],               # "e"    e  = 101 = 0x65 = 1100101b = d + 1  
    $l, $l, $o,            # "llo"
    \@D,                   # " "   ' ' =  32 = 0x20 = 0100000b = 2^5
    [@E, @C, @A, 0, 0, 0], # "W"    W  =  87 = 0x57 = 1010111b = 2^6 + 2^4 + 2^2 + 3
    $o,                    # "o"
    [@$o, 0, 0, 0],        # "r"    r  = 114 = 0x72 = 1110010b = o + 3
    $l, \@d,               # "ld"
    [@D,0]                 # "!"    !  =  33 = 0x21 = 0100001b = 2^5 + 1
— 海科·奥伯迪克
source
似乎我的二元巫毒启发了您：) +1
— masterX244'4
3

Java 389个字符

发现不必要的声明

class A{static int a=0,b=a++,f=a,e=a++;static char p(String s){return(char)Byte.parseByte(s,a);}public static void main(String[]z){long x=e,y=b;String c=((Long)x).toString(),d=((Long)y).toString();char l=p(c+c+d+c+c+d+d),m=p(c+c+d+d+c+d+c),o=(char)(l+a+f),_=p(c+d+d+d+d+d),$=_++;System.out.print(new char[]{p(c+d+d+c+d+d+d),m,l,l,o,$,p(c+d+c+d+c+c+c),o,(char)(o+a+f),l,(char)(m-f),_});}}

历史记录在编辑历史记录中，现在可以读取原始的原始版本：

// H  e  l    l   o      W  o  r   l    d  !
//72,101,108,108,111,32,87,111,114,108,100 33
import static java.lang.Integer.*;
class A
{


    public static void main(String[] args)
    {
        Integer a=0,b=a++,e=a++;  // making a 0 a 1 and a 2 which is required later;
        String c=e.toString(),d=b.toString(),z=c.substring(0,0);  //

        String H = ((char)parseInt(d+c+d+d+c+d+d+d,a))+z+  // make binary values and then to char
                (char)parseInt(d+c+c+d+d+c+d+c,a)+
                (char)parseInt(d+c+c+d+c+c+d+d,a)+
                (char)parseInt(d+c+c+d+c+c+d+d,a)+
                (char)parseInt(d+c+c+d+c+c+c+c,a)+
                (char)parseInt(d+d+c+d+d+d+d+d,a)+
                (char)parseInt(d+c+d+c+d+c+c+c,a)+
                (char)parseInt(d+c+c+d+c+c+c+c,a)+
                (char)parseInt(d+c+c+c+d+d+c+d,a)+
                (char)parseInt(d+c+c+d+c+c+d+d,a)+
                (char)parseInt(d+c+c+d+d+c+d+d,a)+
                (char)parseInt(d+d+c+d+d+d+d+c,a)
                ;
        System.out.println(H);  //obvious
    }
— 大师X244
source
3

Perl 6、199字节

my \O=+[0];my \t=O+O;my \T=t+O;my \f=(t+t,O);my \F=t+T;my \S=T+T;my \L=(S,F);
say [~] ((S,T),(|L,t,0),(my \l=(|L,T,t)),l,(my \o=(|l,O,0)),F,(S,|f,t,0),o,(|L,|f),l,(|L,t),(F,0),)
.map({chr [+] t X**@_})

（添加了换行符以减小宽度，但是不必要，因此不计在内）

Hello World! 被编码为每个字母2的幂的列表。

恰好在一个地方，我有一个文字0用来除0。它用于创建一个元素列表，该列表立即1使用数字前缀运算符（+[0]）转换为数字。

my \O=+[0];    # one          # (List.elems)
my \t=O+O;     # two
my \T=t+O;     # Three
my \f=(t+t,O); # (four, one)  # <W r>
my \F=t+T;     # five
my \S=T+T;     # six

my \L=(S,F);   # lowercase letter  # (6,5)

say [~] (
  (S,T),            # H
  (|L,t,0),         # e
  (my \l=(|L,T,t)), # l
  l,                # l  reuse <l>
  (my \o=(|l,O,0)), # o  reuse <l>, add 0,1
  F,                # ␠
  (S,|f,t,0),       # W
  o,                # o  reuse <o>
  (|L,|f),          # r
  l,                # l  reuse <l>
  (|L,t),           # d
  (F,0),            # !
).map({chr [+] t X**@_})
— 布拉德·吉尔伯特b2gills
source
3

JavaScript 662个字符

O=[[,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[],[,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,]];for(O_O=[].length;O.length>O_O;O_O++)document.write(String.fromCharCode((O[O_O].length||-Math.pow([,,].length,[,,,,,].length)-[,,,,,,,].length)+Math.pow([,,].length,[,,,,,,].length)+Math.pow(++[,].length,[,,,].length)-[,].length));document.write(String.fromCharCode(Math.pow([,,].length,[,,,,,].length)+[,].length))

只是为了拥有一元基数而滥用数组文字呢？该程序具有不使用的优势0。

— 康拉德·鲍罗夫斯基（Konrad Borowski）
source
尽管这可能是有效的，但是这个特殊的难题是代码​​高尔夫球，这意味着您应该针对尽可能短的代码。在600个以上的字符数下，您已经远远没有现有JS解决方案已经拥有的<100个字符数。
— zzzzBov 2012年
1
@zzzzBov：我实际上不是想赢。
— Konrad Borowski 2012年
1
该程序具有不使用的优势0。那O_O=0;呢
— 暴民埃里克
@EriktheGolfer：固定，谢谢。我没注意到那个。
— Konrad Borowski
O_O=[].length可以写成将O_O=false其减少
— 4。– Atmocreations
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.