A tarefa é simples. Escreva um intérprete para o idioma * .

Aqui está um link maior para o wiki.

Existem apenas três programas * válidos:

• * Imprime "Olá, mundo"
•  *  Imprime um número aleatório entre 0 e 2.147.483.647
• *+* Corre para sempre.

O terceiro caso deve ser um loop infinito de acordo com as especificações nesta pergunta

Entrada:

• A entrada pode ser obtida através de qualquer método de entrada aceitável pelas nossas regras de E / S padrão
• Será sempre um dos programas acima

Resultado:

• O primeiro caso deve ser impresso exatamente Hello World, com ou sem uma quebra de linha à direita.
• Para o segundo caso, se o número inteiro máximo do seu idioma for menor que 2.147.483.647, use o número inteiro máximo do seu idioma
• O primeiro e o segundo casos podem ser impressos em qualquer saída aceitável de acordo com nossas regras de E / S padrão.
• O terceiro caso não deve dar saída.

Pontuação:

Como se trata de código-golfe , a resposta mais curta, em bytes, vence.

* , 0 bytes

Como * não tem como ler a entrada, as regras padrão permitem especificar que a entrada deve ser fornecida concatenando-a no programa .

(... eu acho. Existe uma condição "pelo menos o dobro de votos positivos e negativos" que eu não tenho o representante para verificar).

R , 69 bytes

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

Experimente online!

switchtenta corresponder aos argumentos nomeados e, se não houver correspondência, seleciona o primeiro sem nome após o primeiro, que neste caso é o loop infinito repeat{}.

Geléia ,  21  20 bytes

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

Um link monádico que aceita uma lista de caracteres.

Experimente online!

vL’... também funciona (veja abaixo).

Quão?

Ḋ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"

Alternativo

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 bytes

Obrigado a attinat pelos -3 bytes.

Eu só tenho que verificar o segundo caractere: se o LSB estiver definido, é um +(portanto, o programa é " *+*") e o programa faz um loop. Depois disso, se for NUL" *" , o programa foi " " e nós exibimos Hello World; caso contrário, ele exibirá um valor aleatório ("  * ", a única outra opção restante.)

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

Experimente online!

Python 2 , 103 93 89 87 bytes

Eu combinei minha resposta anterior com Chas das Browns resposta e tem algo alguns bytes mais curto.

O número aleatório estará entre 0 e 2 ** 31-1, inclusive.

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

Experimente online!

Versões prévias:

103 bytes

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

93 bytes

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

Barril , -lp, -ir 30 26 25 24 20 19 bytes

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

-1 byte usando sinalizadores

Experimente online!

Histórico de respostas

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

Experimente online!

Encurtada Hello Worldpara a sequência de dicionários

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

Experimente online!

Eu nunca deixei de me surpreender com o poder do barril. Créditos ao usuário EdgyNerd por outro byte salvo.

Versões anteriores

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

Experimente online!

Crédito ao usuário A__ pelo byte extra salvo.

Versão antiga

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

Essencialmente, pega o programa de entrada e:

• Verifica se o comprimento da entrada é 1, imprimindo "Hello World" se true
• Verifica se o último caractere é um espaço e imprime um número aleatório
• Caso contrário, executa um loop infinito

Em seguida, imprima implicitamente a pilha.

?                               #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.

4 bytes salvos devido ao fato de o hello world não precisar de pontuação.

Experimente online! Versão antiga

Experimente online! Nova versão

Befunge-93 , 54 bytes

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

Experimente online!

Anotado:

~"*"-                      _                ~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

A aleatoriedade não é uniforme. A cada incremento, há 50% de chance de parar de incrementar.

Japonês , 22/25 bytes

A primeira solução é para as especificações originais que tinham *<space>como segundo programa e a outra é para as especificações atualizadas que as alteraram arbitrariamente para <space>*</space>, com agradecimentos a EoI pela "correção" sugerida.

Ambos lançam um erro de estouro ao entrar no loop infinito do terceiro programa, mas, teoricamente, com memória suficiente (o que podemos assumir para os propósitos do código-golfe ), funcionaria para sempre.

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

Experimente o programa 1
Experimente o programa 2
Experimente o programa 3

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

Experimente o programa 1
Experimente o programa 2
Experimente o programa 3

JavaScript (ES7), 66 bytes

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

Experimente online! (Olá Mundo)

Experimente online! (número aleatório)

Experimente online! (Loop infinito)

Geléia , 23 21 bytes

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

Experimente online!

Um link monádico pegando um único argumento e retornando Hello World, um inteiro aleatório de 31 bits ou fazendo um loop infinito conforme a especificação.

Todas as opções: * * *+*

Explicação

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 bytes

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

Experimente online!

Python 2 , 91 89 88 bytes

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

Experimente online!

2 bytes graças a Jonathan Allan ; 1 byte thx para o ShadowRanger .

PowerShell, 60 , 56 bytes

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

Consideravelmente versão mudo, a técnica só jogar golfe aqui está omitindo Get-no Get-Random.

UPD. Reduzido para 56 bytes removendo aspas, graças a veskah !

• Experimente online! (Olá Mundo)
• Experimente online! (número aleatório)
• Experimente online! (Loop infinito)

Perl 5 -p , 43 39 bytes

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

Experimente online!

C # (compilador interativo do Visual C #) , 71 bytes

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

Experimente online!

Ruby -n , 47 bytes

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

Experimente online!

Wolfram Language (Mathematica) , 65 bytes

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

Experimente online!

Carvão , 30 bytes

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

Experimente online! Link é a versão detalhada do código. Abusa do formato de entrada padrão do Charcoal, que se divide em espaços se houver apenas uma linha; portanto, a entrada do número aleatório se parece com três entradas. Explicação:

Ｗ№θ*

Repita enquanto a primeira entrada contém a *.

Ｆ⁼θ*

Se a primeira entrada for *apenas uma ...

≔Hello Worldθ

... substitua-o por Hello World, fazendo com que o loop termine. *+*não é substituído, resultando em um loop infinito.

∨θ

Se a primeira entrada não estiver vazia, emita-a.

Ｉ‽Ｘ²¦³¹

Mas se estiver vazio, emita um número inteiro aleatório no intervalo desejado.

Adicionar ++ , 78 bytes

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

Experimente online!

Explicação

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

Braquilog , 26 23 bytes

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

Experimente online!

Leva o programa como uma string pela variável de entrada e ignora a variável de saída. Explora fortemente a garantia de que a entrada é apenas um dos três programas válidos: qualquer entrada de comprimento três se comportará como um " * "ou "*+*"dependendo de o primeiro caractere ser um espaço ou não, e qualquer outra entrada se comportará como "*".

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 bytes

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

Experimente online! (Olá Mundo)

Experimente online! (Número aleatório)

Experimente online! (Loop infinito)

Toma o segundo caractere da entrada que pode ser '', '*'ou '+'. Caso '+'o valor '*'<'+'seja verdadeiro e o loop seja infinito, caso contrário, após o loop, "Hello World" ou um número aleatório é mostrado. Ele rand()gera automaticamente um número entre 0 e os getrandmax()usos definidos RAND_MAXna biblioteca C padrão e, por padrão, está 2147483647na maioria das plataformas / ambientes, incluindo o TIO.

05AB1E , 21 bytes

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

Experimente online. (OBSERVAÇÃO: O buildin aleatório é bastante lento com grandes listas; portanto, pode levar algum tempo até que o resultado seja fornecido.)

Explicação:

'*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)

Veja esta dica 05AB1E meu (seção Como usar o dicionário? ) Para entender por que ”Ÿ™‚ïé "Hello World".

Pitão , 32 bytes

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

Experimente online!

Explicação (Python-ish)

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) , ^{SBCS de} 39 bytes

Prefixo anônimo lambda.

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

Experimente online!

{ "dfn"; ⍵é o argumento:

 '+'∊⍵: se plus é um membro do argumento:

  ∇⍵ cauda recursão no argumento

 ' '∊⍵ se o espaço for um membro do argumento:

  ?0 flutuação aleatória (0–1)

  2E31× escala para (0–2³¹)

  ⌊ chão

 'Hello World' caso contrário, retorne a string

Commodore BASIC (VIC-20, C64, TheC64Mini etc) - 170 bytes tokenize 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

Penso que, para fazer isso com mais precisão, terei que me aprofundar no mundo estranho da linguagem assembly 6502, mas este é um primeiro rascunho.

Primeiro, a INPUTpalavra - chave no Commodore BASIC ignora os espaços em branco; portanto, a sub-rotina em linha 9é uma maneira rápida e suja de aceitar entradas do teclado, incluindo espaços.

Segundo ponto, inteiros Commodore BASIC têm um alcance de 16-bit assinado, por isso -32.768-32.767 fonte - para que eu tenha mantido o número aleatório gerado para 0 - 32767 inclusiva

Wren ,143 135 bytes

Eu não sou um bom jogador de golfe ... O RNG gera o mesmo valor de cada vez porque é um gerador de números pseudo-aleatórios.

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")
}

Experimente online!

JavaScript, 63 bytes, sem recursividade infinita

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

rede ruim, então nenhum link TIO