Desafio

Escreva o programa mais curto P, de modo que

• P pega qualquer número inteiro positivo n como entrada e gera uma sequência de programas P ₁

• executar P ₁ (sem entrada) gera uma sequência de programa P ₂ ,

• executar P ₂ (sem entrada) gera uma sequência de programa P ₃ ,

• ...

• execução de P _n (sem entrada) envia exatamente "Olá!" (sem as aspas).

Esquematicamente:

                P (n) → P ₁ → P ₂ → ... → P _n → Olá!

Critério

• A E / S é via stdin / stdout.
• O comprimento do programa é medido em bytes.
• Os programas consistem apenas em caracteres imprimíveis ASCII.
• Não deve haver duplicatas entre os programas P, P ₁ , ..., P _n .

EDIT: Os programas P, P ₁ , ..., P _n devem ser código fonte e "executar o programa" refere-se a qualquer processamento que produz a saída (ou seja, interpretação, compilação e execução, etc.).

Golfscript 39 14

~'Hello!'{`}@*

Exemplo:

Supondo que n = 4 e nosso programa seja P , estas são as etapas:

1. Execute P com o parâmetro 4 . A saída é "\"\\\"\\\\\\\"Hello!\\\\\\\"\\\"\""( P ₁ )

2. Execução _de saídas P ₁"\"\\\"Hello!\\\"\"" ( P ₂ )

3. Execução _de saídas P ₂"\"Hello!\"" ( P ₃ )

4. Execução _de saídas P ₃"Hello!" ( P ₄ )

5. Executando saídas P ₄Hello! . Se você não confia em mim, siga este link ☺.

JavaScript, 58 caracteres

function $(_){alert(_?$+'$('+--_+')':'Hello!')}$(prompt())

Perl ( 45 36)

say"say q("x($m=<>),"Hello!",")"x$m         

Corra com perl -M5.010para usar say.

For n=1, saídas say q(Hello!)
For n=2, saídas say q(say q(Hello!))
Para n=3, saídas say q(say q(say q(Hello!)))
e assim por diante.

Python3, 66

r="print(%r)";e=eval;n=e(input())+1;e(e("(r%"*n+"'Hello!'"+")"*n))

Lisp comum, 68 caracteres

(do((n(read)(1- n))(s'(princ"Hello!")`(print',s)))((= 0 n)(eval s)))

(do ((n (read) (1- n))
     (s '(princ "Hello!") `(print ',s)))
    ((= 0 n) (eval s)))

A única coisa não-direta: gera mais um nível de programa do que o necessário e avalia-o, porque evalé um caractere menor que print.

Lisp comum: 65

#1=(SETF N(READ)(CADDR'#1#)(1- N)W(PRINT(IF(= N 0)"Hello!"'#1#)))

Esta versão é menor que a resposta CL existente. Caso seu Lisp coaxe com um stackoverflow, você precisará usar isso, 81 bytes:

#1=(SETF N(READ)*PRINT-CIRCLE* T(CADDR'#1#)(1- N)W(PRINT(IF(= N 0)"Hello!"'#1#)))

Sei que estou atrasado para a festa e tenho certeza de que isso ainda pode ser otimizado.

Demonstração (cuidado, alguns REPLs on-line não funcionam corretamente):

* #1=(SETF N(READ)*PRINT-CIRCLE* T(CADDR'#1#)(1- N)W(PRINT(IF(= N 0)"Hello!"'#1#)))
2
#1=(SETF N 1
         *PRINT-CIRCLE* T
         (CADDR '#1#) (1- N)
         W
           (PRINT
            (IF (= N 0)
                "Hello!"
                '#1#))) 
#1=(SETF N 1
         *PRINT-CIRCLE* T
         (CADDR '#1#) (1- N)
         W
           (PRINT
            (IF (= N 0)
                "Hello!"
                '#1#)))
* (eval *)

#1=(SETF N 0
         *PRINT-CIRCLE* T
         (CADDR '#1#) (1- N)
         W
           (PRINT
            (IF (= N 0)
                "Hello!"
                '#1#))) 
#1=(SETF N 0
         *PRINT-CIRCLE* T
         (CADDR '#1#) (1- N)
         W
           (PRINT
            (IF (= N 0)
                "Hello!"
                '#1#)))
* (eval *)
"Hello!" 
"Hello!"
* 

Observe que:

• Testado usando SBCL 1.2.11.debian

• Existem muitos avisos porque estou fazendo coisas que não deveriam ser feitas com seriedade. Felizmente, todos os avisos são impressos com ponto-e-vírgula, para que sejam tratados como comentários de qualquer maneira.

• A duplicação ocorre porque um é o valor de retorno e uma saída real. Se o valor de retorno também conta, simplifica para 58 bytes:#1=(SETF N(READ)(CADDR'#1#)(1- N)W(IF(= N 0)"Hello!"'#1#))

• Eu ainda sei que estou atrasado para a festa

Python 2.7, 57

print reduce(lambda x,y:y+`x`,input()*["print"],"Hello!")

Haskell, 62

main=interact$(iterate(("main=putStr"++).show)"Hello!"!!).read

Bash, 47 ou 12 (se eu usar golfbash)

Código:

read x;for((;x>=0;x--)){ O+=" echo";};$O Hello!

código golfbash:

R;n e Hello!

Código anterior (49):

read x;E=echo;eval \"\${E[0]\"{0..$x}\"}\" Hello!

Usar:

Tornar programa P

$ echo '<paste code here>' > P

$ chmod +x P

Exemplo

Faça P1:

$> echo 4 | ./P > 
echo echo echo echo Hello!

Faça P2:

$> echo 4 | ./P | bash
echo echo echo Hello!

Faça P3:

$ echo 4 | ./P | bash | bash
echo echo Hello!

Faça P4:

$ echo 4 | ./P | bash | bash | bash
echo Hello!

Execute P4:

$ echo 4 |./P | bash | bash | bash | bash
Hello!

Digamos que eu criei uma nova linguagem de uso geral chamada golfbash - parecida com golfscript - que possui alguns comandos úteis como estes:

R which reads stdin and places result into variable $REPLY.
n $1 $2 which echo's $1 $REPLY times followed by $2.
e which echo's all parameters to stdout.

Então eu poderia escrever isso:

R;n e Hello!

Isso seria legal, não é?

F #, 182

let say msg = sprintf "%s" msg
let gen num = 
    let rec g n a =
        match n with
        | i when i > 0 -> g (i-1) ("say \"" + a + "\"")
        | _ -> say a
    g num "Hello!"

J - 31 char

Lembre-se de que J usa seqüências de caracteres no estilo Pascal: 'It''s too easy!'

'Hello!'(],,)''''#~<:2^".1!:1]1

Explicado:

• ".1!:1]1 - Leia uma linha do stdin e converta-a em um número.
• <:2^ - Leve 2 para a potência desse número e diminua.
• ''''#~ - Faça uma sequência com tantas cópias do caractere de aspas simples.
• 'Hello!'(],,)- Anexe essas aspas à frente e atrás de Hello!.

Uso:

   'Hello!'(],,)''''#~<:2^".1!:1]1   NB. let's try 3
3
'''''''Hello!'''''''
   '''''''Hello!'''''''  NB. P1
'''Hello!'''
   '''Hello!'''          NB. P2
'Hello!'
   'Hello!'              NB. and P3 prints Hello!
Hello!

Python 2.7: 75

def h(n):
 return "Hello"if n<1 else'print %s' % `h(n-1)`
print h(input())

Golfe pela primeira vez, não tenho certeza se estou fazendo certo; p

Clojure, 36 bytes

(str(apply str(repeat 5\'))"Hello!")

Símbolo

'something

avalia como

something

Crie um símbolo com 5 aspas simples e execute o resultado até que não haja mais aspas.