Este é um desafio muito simples.

A linguagem da piada InterpretMe consiste em um comando; *, o que faz com que o programa receba a entrada de um programa InterpretMe e o execute.

Um programa InterpretMe interpretará quantos programas InterpretMe houver *na entrada.

Seu objetivo é criar um programa que interprete o InterpretMe no menor número de bytes possível.

Entrada

A entrada consistirá em seqüências ASCII de uma linha, sequências unicode utf-8, se você realmente quiser, ou em qualquer codificação de caracteres que seu idioma utilize, se você desejar muito. Essas cadeias podem ser inseridas no início ou no início de cada execução do interpretador InterpretMe. Se todas elas forem inseridas no início, o programa deverá emitir todas as linhas do programa assim que for iniciado.

Resultado

Nesse desafio, não haverá saída, a menos que a opção de uma entrada seja escolhida; caso contrário, somente terminação e não terminação

Os casos de teste consistem não em entrada e saída, mas em entrada e finalização. Uma nova linha indica uma nova entrada a ser interpretada como InterpretMe.

Se estiver usando uma entrada no início, pode ser considerado o que é gerado quando esses programas são inseridos, seguido por linhas inativas (não faça 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]

Novamente, isso é código-golfe , então menos bytes é melhor

05AB1E , 11 bytes

Código:

[¬'*QiIJ}¦Ž

Explicação:

[            # 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

Usa a codificação CP-1252 . Experimente online? .

Python 3, 35 bytes

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

define i como um, adiciona a quantidade de '*' -1 a i

Eu acho que posso reduzir isso com ~truques que não consegui

Python 3, 39 38 bytes

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

Guardado 1 byte graças a @atlasologist

Ruby, 29 bytes

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

A variável mágica do Ruby $.rastreia o número de linhas lidas no stdin. Continue lendo a entrada enquanto esse número for menor que a contagem de asteriscos (mais o 1 inicial).

JavaScript, 53 45 44 bytes

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

Este programa é bastante irritante de usar devido à falta de boas E / S do JavaScript.

Solicita um programa e, em seguida, solicita outro programa para cada um *no programa de entrada.

Apenas Java 45 60 101 100 99 bytes

Código reverso de golfe: D. Percebi que li errado as especificações (duas vezes), mas agora deve funcionar. Parece bastante simples, talvez haja uma maneira melhor de escrever isso como uma expressão lamda.

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

Trapaça levemente desprezível por apenas 17 bytes!

void a(char[]a){}

Esta versão terá entrada via digitação muito rápida

Mathematica, 38 bytes

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

APL, 15 bytes

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

Teste:

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

Explicação:

              ⍞  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--){}

Conta o número de vezes que * ocorre na entrada e adiciona isso ao número de vezes que ele faz um loop. Eu sinto que deveria haver uma maneira de fazer o decremento na mesma etapa do incremento, mas não consegui descobrir.