Este es un desafío muy simple.

El lenguaje de broma InterpretMe consta de un comando; *, lo que hace que el programa tome la entrada de un programa InterpretMe y lo ejecute.

Un programa InterpretMe interpretará tantos programas InterpretMe como haya *en la entrada.

Su objetivo es crear un programa que interprete InterpretMe en la menor cantidad de bytes posible.

Entrada

La entrada consistirá en cadenas ASCII de una línea, cadenas utf-8 unicode si realmente lo desea, o cualquier codificación de caracteres que utilice su idioma, si así lo desea. Estas cadenas se pueden ingresar al inicio o al comienzo de cada ejecución del intérprete InterpretMe. Si todos se ingresan al inicio, el programa debe generar cada línea de programa a medida que comienza.

Salida

En este desafío, no habrá salida a menos que se elija la opción de una entrada, de lo contrario, solo terminación y no terminación

Los casos de prueba consisten no en entrada y salida, sino en entrada y terminación. Una nueva línea denota una nueva entrada para ser interpretada como InterpretMe.

Si usa una entrada al inicio, esto podría considerarse lo que se genera cuando se ingresan estos programas, seguido de líneas inactivas (no hacer nada).

1. *   (executes input as an interpret me program, finishes)
2. *   (^same)
3. **  (executes input as an interpret me program, then does this again after the first program is done, finishes)
4. hi  (nothing, first star of previous line finishes)
5. **  (same as the other two star line)
6. hi  (nothing, first star of previous line finishes)
7. hi  (nothing, second star of line 5 finishes, so second star of line 3 finishes, so line 2 finishes, so line one finishes)
[termination] (not outputted)

hi  (does nothing and finishes)
[termination]

*hi  (executes inputted program, finishes)
*yo  (executes inputted program, finishes)
hey  (nothing)
[termination]

Nuevamente, esto es código golf , por lo que menos bytes es mejor

05AB1E , 11 bytes

Código:

[¬'*QiIJ}¦Ž

Explicación:

[            # Enter an infinite loop
 ¬           # Get the first character of the input string (leaves the input on the stack)
  '*Qi  }    # If equal to an asterisk...
      I      # Request another line of input and
       J     # Join it to the string that was left on the stack
         ¦   # Remove the first character
          Ž  # If everything is processed, terminate

Utiliza la codificación CP-1252 . Pruébalo en línea? .

Python 3, 35 bytes

i=1
while i:i+=input().count('*')-1

establece i en uno, agrega la cantidad de '*' -1 a i

Creo que puedo reducir esto con ~trucos que no pude

Python 3, 39 38 bytes

def f():[f()for c in input()if c=="*"]

Guardado 1 byte gracias a @atlasologist

Ruby, 29 bytes

i=1
i+=gets.count ?*while$.<i

La variable mágica de Ruby $.realiza un seguimiento del número de líneas leídas de stdin. Siga leyendo mientras este número es inferior al recuento de asteriscos (más el 1 inicial).

JavaScript, 53 45 44 bytes

f=_=>{for(i in prompt().match(/\*/g))f()}f()

Este programa es bastante molesto de usar debido a la falta de buena E / S de JavaScript.

Pide un programa, luego solicita otro programa para cada *entrada del programa.

Java solamente 45 60101100100 99 bytes

Código de golf inverso: D. Noté que leí mal las especificaciones (dos veces), pero ahora debería funcionar. Parece bastante simple, tal vez hay una mejor manera de escribir esto como una expresión lamda.

void a(char[]a){for(char b:a)if(b==42)a(new java.util.Scanner(System.in).nextLine().toCharArray());}

¡Trampa ligeramente sórdida por solo 17 bytes!

void a(char[]a){}

Esta versión tendrá entrada a través de una escritura realmente rápida

Mathematica, 38 bytes

f:=StringCases[InputString[],"*":>f];f

APL, 15 bytes

{⍵='*':∇¨⍞⋄⍬}¨⍞

Prueba:

      {⍵='*':∇¨⍞⋄⍬}¨⍞
*
*
**
hi
**
hi
hi
⍝ termination

Explicación:

              ⍞  read a line from the keyboard
{           }¨   for each character:
 ⍵='*':          if it is *:
         ⍞         read another line from the keyboard
       ∇¨          do the same for each character
          ⋄⍬     otherwise, return empty list (which displays as nothing)

Perl, 33 bytes

for(my$c;$c+=()=<>=~/\*/g;$c--){}

Cuenta el número de veces que * ocurre en la entrada y lo agrega al número de veces que se repite. Siento que debería haber una manera de hacer la disminución en el mismo paso que el incremento, pero no pude resolverlo.