La tarea es simple. Escribe un intérprete para el idioma * .

Aquí hay un enlace más grande a la wiki.

Solo hay tres programas válidos *:

• * Imprime "Hola mundo"
•  *  Imprime un número aleatorio entre 0 y 2,147,483,647
• *+* Corre por siempre.

El tercer caso debe ser un bucle infinito de acuerdo con las especificaciones de esta pregunta.

Entrada:

• La entrada se puede tomar a través de cualquier método de entrada aceptable según nuestras reglas estándar de E / S
• Siempre será uno de los programas anteriores.

Salida:

• El primer caso debe imprimirse exactamente Hello World, con o sin un salto de línea final.
• Para el segundo caso, si el número entero de su idioma es menor que 2,147,483,647, use el número entero de su idioma
• El primer y el segundo caso pueden imprimirse en cualquier salida aceptable según nuestras reglas de E / S estándar.
• El tercer caso no debe dar ningún resultado.

Puntuación:

Como se trata de código de golf , la respuesta más corta, en bytes, gana.

* , 0 bytes

Como * no tiene forma de leer la entrada, las reglas predeterminadas permiten especificar que la entrada se debe dar concatenando en el programa .

(... creo. Hay una condición de "al menos el doble de votos positivos que negativos" que no tengo el representante para verificar).

R , 69 bytes

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

Pruébalo en línea!

switchintenta hacer coincidir los argumentos con nombre y si no hay coincidencia, selecciona el primero sin nombre después del primero, que en este caso es el bucle infinito repeat{}.

Jalea ,  21  20 bytes

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

Un enlace monádico que acepta una lista de personajes.

Pruébalo en línea!

vL’... También funciona (ver más abajo).

¿Cómo?

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

Alternativa

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

Gracias a attinat por los -3 bytes.

Solo tengo que verificar el segundo carácter: si el LSB está configurado, es un +(por lo tanto, el programa es " *+*") y el programa se repite. Después de eso, si es a NUL, el programa fue " *" y mostramos Hello World; de lo contrario, muestra un valor aleatorio ("  * ", la única otra opción que queda).

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

Pruébalo en línea!

Python 2 , 103 93 89 87 bytes

Combiné mi respuesta anterior con Chas Cafés de respuesta y tengo algo unos pocos bytes más corto.

El número aleatorio estará entre 0 y 2 ** 31-1 inclusive.

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

Pruébalo en línea!

Versión anterior:

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]

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

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

-1 byte usando banderas

Pruébalo en línea!

Historial de respuestas

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

Pruébalo en línea!

Acortado Hello Worlda cadena de diccionario

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

Pruébalo en línea!

Nunca dejé de sorprenderme con el poder de Keg. Créditos al usuario EdgyNerd por otro byte guardado.

Versiones anteriores

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

Pruébalo en línea!

Crédito al usuario A__ por el byte adicional guardado.

Versión antigua

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

Esencialmente, toma el programa de entrada y:

• Comprueba si la longitud de entrada es 1, imprimiendo "Hello World" si es verdadero
• Comprueba si el último carácter es un espacio e imprime un número aleatorio
• De lo contrario, ejecuta un bucle infinito

Luego implícitamente imprima la pila.

?                               #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 guardados debido a que hello world no necesita puntuación.

Pruébalo en línea! Versión antigua

Pruébalo en línea! Nueva versión

Befunge-93 , 54 bytes

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

Pruébalo en línea!

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

La aleatoriedad no es uniforme. En cada incremento hay un 50% de posibilidades de dejar de incrementar.

Japt , 22/25 bytes

La primera solución es para la especificación original que tenía *<space>como segundo programa y la otra es para la especificación actualizada que lo cambió arbitrariamente <space>*</space>, gracias a EoI por la "solución" sugerida.

Ambos arrojan un error de desbordamiento al ingresar al bucle infinito del tercer programa, pero, teóricamente, con suficiente memoria (que podemos suponer a los efectos del código de golf ), correría para siempre.

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

Pruebe el programa 1
Pruebe el programa 2
Pruebe el programa 3

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

Pruebe el programa 1
Pruebe el programa 2
Pruebe el programa 3

JavaScript (ES7), 66 bytes

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

Pruébalo en línea! (Hola Mundo)

Pruébalo en línea! (número aleatorio)

Pruébalo en línea! (Bucle infinito)

Jalea , 23 21 bytes

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

Pruébalo en línea!

Un enlace monádico que toma un solo argumento y regresa Hello World, un entero aleatorio de 31 bits o que se repite infinitamente según la especificación.

Todas las opciones: * * *+*

Explicación

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();}

Pruébalo en línea!

Python 2 , 91 89 88 bytes

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

Pruébalo en línea!

2 bytes gracias a Jonathan Allan ; 1 byte gracias a ShadowRanger .

PowerShell, 60 , 56 bytes

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

Bastante versión muda, la técnica sólo jugar al golf aquí está omitiendo Get-en Get-Random.

UPD ¡Despojado a 56 bytes eliminando comillas, gracias a veskah !

• Pruébalo en línea! (Hola Mundo)
• Pruébalo en línea! (número aleatorio)
• Pruébalo en línea! (Bucle infinito)

Perl 5 -p , 43 39 bytes

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

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 71 bytes

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

Pruébalo en línea!

Ruby -n , 47 bytes

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

Pruébalo en línea!

Wolfram Language (Mathematica) , 65 bytes

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

Pruébalo en línea!

Carbón , 30 bytes

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

Pruébalo en línea!El enlace es a la versión detallada del código. Abusa del formato de entrada predeterminado de Charcoal que se divide en espacios si solo hay una línea, por lo que la entrada de números aleatorios en realidad se parece a tres entradas. Explicación:

Ｗ№θ*

Repita mientras la primera entrada contiene un * .

Ｆ⁼θ*

Si la primera entrada es un * solo ...

≔Hello Worldθ

... luego reemplácelo con Hello World , haciendo que el ciclo termine. *+*no se reemplaza, lo que resulta en un bucle infinito.

∨θ

Si la primera entrada no está vacía, expórtela.

Ｉ‽Ｘ²¦³¹

Pero si está vacío, genera un número entero aleatorio en el rango deseado.

Añadir ++ , 78 bytes

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

Pruébalo en línea!

Explicación

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 bytes

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

Pruébalo en línea!

Toma el programa como una cadena a través de la variable de entrada e ignora la variable de salida. Explota enormemente la garantía de que la entrada es solo uno de los tres programas válidos: cualquier entrada de longitud tres se comportará como " * "o "*+*"dependiendo de si el primer carácter es un espacio, y cualquier otra 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';

Pruébalo en línea! (Hola Mundo)

Pruébalo en línea! (Número aleatorio)

Pruébalo en línea! (Bucle infinito)

Toma el segundo carácter de entrada que puede ser '', '*'o '+'. En el caso de '+'la '*'<'+'será verdad y el bucle será infinito, de lo contrario, después del bucle, se muestra "Hola mundo" o un número aleatorio. El rand()emite automáticamente un número entre 0 y getrandmax()que utiliza definidas RAND_MAXen la biblioteca C estándar y por defecto es 2147483647en la mayoría de plataformas / entornos, incluyendo TIO.

05AB1E , 21 bytes

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

Pruébalo en línea.(NOTA: El buildin aleatorio es bastante lento con grandes listas, por lo que puede pasar un tiempo antes de que se dé el resultado).

Explicación:

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

Ver este consejo 05AB1E mío (sección Cómo usar el diccionario? ) Para entender por qué ”Ÿ™‚ïes "Hello World".

Pyth , 32 bytes

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

Pruébalo en línea!

Explicación (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

Prefijo anónimo lambda.

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

Pruébalo en línea!

{ "dfn"; ⍵es el argumento:

 '+'∊⍵: si plus es miembro del argumento:

  ∇⍵ cola recurse en argumento

 ' '∊⍵ si el espacio es un miembro del argumento:

  ?0 flotante aleatorio (0-1)

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

  ⌊ piso

 'Hello World' de lo contrario devolver la cadena

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

Creo que para hacer esto con mayor precisión, tendré que profundizar en el extraño mundo del lenguaje ensamblador 6502, pero este es un primer borrador.

Primer punto, la INPUTpalabra clave en Commodore BASIC ignora los espacios en blanco, por lo que la subrutina en línea 9es una forma rápida y sucia de aceptar entradas de teclado que incluyen espacios.

Segundo punto, los números enteros Commodore BASIC tienen un rango de 16 bits con signo, por lo que -32768 a +32767 fuente , así que he mantenido el número aleatorio generado a 0 - 32767 inclusive

Reyezuelo ,143 135 bytes

No soy un buen jugador de golf ... El RNG genera el mismo valor cada vez porque es un generador de números pseudoaleatorio.

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

Pruébalo en línea!

JavaScript, 63 Bytes, no recursivo infinito

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

mala red, así que no hay enlace TIO