任务很简单。为*语言编写口译员。

这是Wiki的更大链接。

只有三个有效的*程序：

• * 打印“ Hello World”
•  *  打印0到2,147,483,647之间的随机数
• *+* 永远运行。

根据此问题的规范，第三种情况必须是无限循环

输入：

• 可以通过我们的标准I / O规则通过任何可接受的输入方法进行输入
• 它将永远是以上程序之一

输出：

• 第一种情况应打印准确Hello World，带有或不带有尾行。
• 对于第二种情况，如果您的语言的整数最大值小于2,147,483,647，请使用您的语言的整数最大值
• 根据我们的标准I / O规则，第一种情况和第二种情况可以打印到任何可接受的输出。
• 第三种情况不应给出任何输出。

得分：

因为这是代码高尔夫球，所以最短的答案（以字节为单位）获胜。

*，0字节

由于*无法读取输入，因此默认规则允许指定必须通过将输入连接到程序来给出输入。

（...我认为。存在“至少两倍于向下投票的数量”的情况，我没有代表可以验证）。

R，69字节

switch(scan(,""),"*"="Hello, World!"," * "=sample(2^31,1)-1,repeat{})

在线尝试！

switch尝试匹配命名的参数，如果不匹配，请选择第一个未命名的参数，然后选择第一个未命名的参数，在本例中为无限循环repeat{}。

果冻， 21  20字节

ḊOSØ%HX’¤“½,⁾ẇṭ»¹Ḃ¿?

接受字符列表的单子链接。

在线尝试！

vL’... 也可以（见下文）。

怎么样？

ḊOSØ%HX’¤“½,⁾ẇṭ»¹Ḃ¿? - Link: list of characters   e.g.: "*"        or  " * "    or  "*+*"
Ḋ                    - dequeue                          ""             "* "         "+*"
 O                   - to ordinals                      []             [42,32]      [43,42]
  S                  - sum                              0              74           85
                   ? - if...
                  ¿  - ...if-condition: while...
                 Ḃ   -    ...while-condition: modulo 2  0              0            1
                ¹    -    ...while-true-do: identity                                85
                     -                                  0              74           (looping)
        ¤            - ...then: nilad followed by link(s) as a nilad:
   Ø%                -    literal 2^32                                 2^32
     H               -    half                                         2^31
      X              -    random integer in [1,n]                      RND[1,2^31]
       ’             -    decrement                                    RND[0,2^31)
         “½,⁾ẇṭ»     - ...else: dictionary words        "Hello World"

另类

vL’... - Link: list of characters                 e.g.: "*"        or  " * "    or  "*+*"
 L     - length                                         1              3            3
v      - evaluate (left) as Jelly code with input (right)
       -                                                1^1            3^3          (3^3+3)^3
       -                                                1              27           27000
  ’    - decrement                                      0              26           26999
   ... - continue as above                              "Hello World"  RND[0,2^31)  (looping)

C（gcc），66 63字节

感谢attinat的-3个字节。

我只需要检查第二个字符：如果设置了LSB，则它是a +（因此程序为“ *+*”）并且程序循环。之后，如果是a NUL，则程序为“ *”，然后显示Hello World；否则，它将显示一个随机值（“  * ”，剩下的唯一其他选项。）

f(char*s){for(s++;*s&1;);printf(*s?"%d":"Hello World",rand());}

在线尝试！

Python 2中，103个 93 89 87字节

我将先前的答案与Chas Browns的答案结合在一起，得到的结果短了几个字节。

随机数将介于0和2 ** 31-1之间（含0和2 ** 31-1）。

from random import*
i=input()
while'*'<i:1
print["Hello World",randrange(2**31)][i<'!']

在线尝试！

之前的版本：

103字节

from random import*
exec['print"Hello World"','while 1:1','print randint(0,2**31-1)'][cmp(input(),'*')]

93字节

from random import*
i=cmp(input(),'*')
while i>0:1
print["Hello World",randint(0,2**31-1)][i]

小桶，-lp，-ir 30 26 25 24 20 19个字节

!1=[_“H%c¡“| =[~.|{

-1字节使用标志

在线尝试！

回答历史

?!1=[_“H%c¡“| =[~.|{

在线尝试！

缩短Hello World为字典字符串

!1=[_Hello World| =[~.|{

在线尝试！

我从未对Keg的强大能力感到惊讶。向用户EdgyNerd存入另一个字节。

先前版本

_!0=[Hello World|\*=[~.|{

在线尝试！

将节省的额外字节记入用户A__。

旧版本

?!1=[_Hello World| =[__~|{

本质上，采用输入程序并：

• 检查输入长度是否为1，如果为true，则打印“ Hello World”
• 检查最后一个字符是否为空格，并打印一个随机数
• 否则运行无限循环

然后隐式打印堆栈。

?                               #Get input from the user
 !1=                            #Compare the stack's length to 1
    [_Hello World           #Push "Hello, World!" to the stack
                     | =        #See if top item is a space
                        [__~|{  #If so, generate a random number, otherwise, infinite loop.

由于hello world不需要标点符号，因此节省了4个字节。

在线尝试！旧版本

在线尝试！新版本

Befunge-93，54个字节

~"*"-_~1+#^_"dlroW olleH">:#,_@.%*2**:*::*88:*`0:?1#+<

在线尝试！

注释：

~"*"-                      _                ~1+                   #^_        "dlroW olleH">:#,_    @      .%*2**:*::*88:   *`0:             ?1#+<
Compare first      If equal, go right       Compare second       If equal,        Output          Exit    Modulo by 2^31   If less than      Add 1
character to       Otherwise, go left       character to       loop forever   "Hello World"                 and output     0, multiply     a random amount
'*'                and wrap around          -1 (EOF)                                                                         by 0            of times

随机性不均匀。每增加一次，就有50％的机会停止增加。

Japt，22/25字节

第一个解决方案是针对具有*<space>第二个程序的原始规范的，而另一个解决方案则是针对<space>*</space>EoI建议的“修复”功能，将其随意更改为更新的规范。

两者都在进入第三个程序的无限循环时引发溢出错误，但是从理论上讲，如果有足够的内存（我们可能会出于代码高尔夫的目的假定），它将永远运行。

Å?¢?ß:2pHÉ ö:`HÁM Wld

尝试程序1
尝试程序2
尝试程序3

Å?UÎ>S?ß:2pHÉ ö:`HÁM Wld

尝试程序1
尝试程序2
尝试程序3

JavaScript（ES7），66个字节

s=>s[1]?s<'!'?Math.random()*2**31|0:eval(`for(;;);`):'Hello World'

在线尝试！（你好，世界）

在线尝试！（随机数）

在线尝试！（无限循环）

果冻，23 21字节

OS¹Ḃ¿ịØ%HX’;““½,⁾ẇṭ»¤

在线尝试！

单值链接，采用单个参数并返回Hello World，随机的31位整数或按规范无限循环。

所有选项： * * *+*

说明

O                     | Convert to codepoints
 S                    | Sum
  ¹Ḃ¿                 | Loop the identity function while odd 
     ị              ¤ | Index into the following as a nilad:
      Ø%              | - 2 ** 32
        H             | - Halved
         X            | - Random integer in the range 1..2**31
          ’           | - Decrease by 1 
           ;          | - Concatenated to:
            ““½,⁾ẇṭ»  |   - "", "Hello World"

Java（JDK），83个字节

s->{for(s=s.intern();s=="*+*";);return"*"==s?"Hello World":(-1>>>1)*Math.random();}

在线尝试！

Python 2中，91个 89 88字节

from random import*
def f(p):
 while'*'<p:p
 print['Hello World',getrandbits(31)][p<'!']

在线尝试！

感谢Jonathan Allan 2个字节；ShadowRanger传送 1个字节。

PowerShell中，60，56个字节

switch($args){*{'Hello World'}' * '{random}*+*{for(){}}}

非常愚蠢的版本，这里唯一的高尔夫技术省略Get-在Get-Random。

UPD。多亏了veskah，通过删除引号将其缩减为56个字节！

• 在线尝试！（你好，世界）
• 在线尝试！（随机数）
• 在线尝试！（无限循环）

Perl 5中 -p，43 39个字节

$_=/ /?0|rand~0:/\+/?redo:"Hello World"

在线尝试！

C＃（Visual C＃交互式编译器），71字节

s=>{for(;s=="*+*";);return"*"==s?"Hello World":new Random().Next()+"";}

在线尝试！

Ruby -n，47个字节

puts~/ /?rand(1<<31):~/\+/?loop{}:"Hello World"

在线尝试！

Wolfram语言（Mathematica），65字节

#/.{"*"->"Hello World"," * "->RandomInteger[2^31-1],_:>0~Do~∞}&

在线尝试！

木炭，30字节

Ｗ№θ*Ｆ⁼θ*≔Hello Worldθ∨θＩ‽Ｘ²¦³¹

在线尝试！链接是详细版本的代码。滥用木炭的默认输入格式，如果只有一行，则会在空格处分割，因此随机数输入实际上看起来像三个输入。说明：

Ｗ№θ*

在第一个输入包含时重复上述步骤*。

Ｆ⁼θ*

如果第一个输入是*唯一的...

≔Hello Worldθ

...然后将其替换为Hello World，从而导致循环终止。*+*不会被替换，从而导致无限循环。

∨θ

如果第一个输入不为空，则输出它。

Ｉ‽Ｘ²¦³¹

但是，如果为空，则输出所需范围内的随机整数。

加++，78字节

z:"Hello World"
`y
xR2147483647
x:?
a:"*"
b:" * "
c:"*+*"
Ix=a,Oz
Ix=b,O
Wx=c,

在线尝试！

说明

z:"Hello World"	; Set z = "Hello World"
`y		; Set y as the active variable
xR2147483647	; Set y to a random number between 0 and 2147483647
x:?		; Set x to the input
a:"*"		; Set a = "*"
b:" * "		; Set b = " * "
c:"*+*"		; Set c = "*+*"
Ix=a,		; If x == a then...
	Oz	;	...output z
Ix=b,		; If x == b then...
	O	;	...output y
Wx=c,		; While x == c then...
		;	...do nothing

Brachylog，26 23字节

l₃∈&hṢ∧2^₃₁-₁ṙw∨Ḥ⊇ᶠ³⁶tw

在线尝试！

通过输入变量将程序作为字符串，而忽略输出变量。大量利用以下保证：输入仅是三个有效程序之一：任何长三输入都将像任一输入，" * "或者"*+*"取决于第一个字符是否为空格，而其他输入都将像"*"。

l₃                         The input has length 3
  ∈                        and is an element of something,
   &h                      and the input's first element
     Ṣ                     is a space
  ∈                        (if not, try some other thing it's an element of),
      ∧2^₃₁-₁              so take 2,147,483,647 and
             ṙw            print a random number between 0 and it inclusive.
               ∨           If the input's length isn't 3,
                Ḥ⊇ᶠ³⁶tw    print the 36th subsequence of "Hello, World!".

PHP，51字节

for(;'*'<$l=$argn[1];);echo$l?rand():'Hello World';

在线尝试！（你好，世界）

在线尝试！（随机号码）

在线尝试！（无限循环）

取输入的第二字符可以是''，'*'或'+'。在以下情况下'+'的'*'<'+'将是真正的循环将是无限的，否则，在循环后，“Hello World”的或随机数显示。该rand()自动输出0和之间的数字getrandmax()定义的用途RAND_MAX在标准C库缺省情况下为2147483647在大多数平台/环境，包括TIO。

05AB1E，21 字节

'*KgDi[ë<ižIL<Ω딟™‚ï

在线尝试。（注意：使用大型列表时，随机构建速度非常慢，因此可能需要一段时间才能给出结果。）

说明：

'*K           '# Remove all "*" from the (implicit) input
   g           # Get the length of what's remain (either 0, 1, or 2)
    D          # Duplicate this length
     i         # If the length is exactly 1:
      [        #  Start an infinite loop
     ë<i       # Else-if the length is 2:
        žI     #  Push builtin 2147483648
          L    #  Create a list in the range [1,2147483648]
           <   #  Decrease each by 1 to make the range [0,2147483647]
            Ω  #  Pop and push a random value from the list
               #  (after which the top of the stack is output implicitly as result)
     ë         # Else:
      ”Ÿ™‚ï    #  Push dictionary string "Hello World"
               #  (after which the top of the stack is output implicitly as result)

见我这个05AB1E尖端（部分如何使用字典？）理解为什么”Ÿ™‚ï是"Hello World"。

Pyth，32个字节

It/Jw\*#;?tlJOhC*4\ÿ"Hello World

在线尝试！

说明（Python式）

I                                   # if 
  /Jw\*                             #    (J:=input()).count("*"))
 t                                  #                             - 1:
       #;                           #     try: while True: pass;except: break;
         ?                          # if (ternary)
           lJ                       #    len(J):
             O                      #     randInt(0,                    )
               C                    #                int(     , 256)
                *4\ÿ                #                    4*"ÿ"
              h                     #                                + 1
                    "Hello World    # else: (implicitly) print "Hello World"

APL（Dyalog Unicode），39 字节^SBCS

匿名前缀lambda。

{'+'∊⍵:∇⍵⋄' '∊⍵:⌊2E31×?0⋄'Hello World'}

在线尝试！

{ “ dfn”；⍵是参数：

 '+'∊⍵: 如果plus是参数的成员：

  ∇⍵ 尾随递归

 ' '∊⍵ 如果space是参数的成员：

  ?0 随机浮动（0–1）

  2E31× 缩放到（0–2³¹）

  ⌊ 地板

 'Hello World' 否则返回字符串

Commodore BASIC（VIC-20，C64，TheC64Mini等）-170标记化BASIC字节

 0a%=32767:goS9:b$=leF(b$,len(b$)-1):ifb$="*"tH?"hello world
 1ifb$=" * "tH?int(rN(ti)*a%)
 2ifb$="*+*"tHfOi=.to1:i=.:nE
 3end
 9b$="":fOi=.to1:geta$:i=-(a$=cH(13)):b$=b$+a$:?a$;:nE:reT

我认为要更准确地执行此操作，我将不得不深入研究6502汇编语言的怪异世界，但这是初稿。

首先，INPUTCommodore BASIC中的关键字会忽略空格，因此该行的子例程9是一种接受包含空格的键盘输入的快捷方法。

第二点，准将BASIC整数具有16位带符号范围，因此从-32768到+32767是源 -因此，我将生成的随机数保持为0-32767（含）

雷恩，143 135字节

我不是一个好高尔夫球手... RNG每次都会生成相同的值，因为它是一个伪随机数生成器。

Fn.new{|a|
import"random"for Random
if(a=="*+*"){
while(1){}
}else System.write(a[0]==" "?Random.new(9).int((1<<31)-1):"Hello World")
}

在线尝试！

JavaScript，63字节，无无限递归

s=>s[1]?Math.random()*2**31|eval("while(s>'!');"):'Hello World'

网络故障，因此没有TIO链接