Desafío

Escriba el programa más corto P de manera que

• P toma cualquier número entero positivo n como entrada y emite una cadena de programa P ₁

• ejecutar P ₁ (sin entrada) genera una cadena de programa P ₂ ,

• ejecutar P ₂ (sin entrada) genera una cadena de programa P ₃ ,

• ...

• ejecutar P _n (sin entrada) genera exactamente "¡Hola!" (sin las comillas).

Esquemáticamente:

                P (n) → P ₁ → P ₂ → ... → P _n → ¡Hola!

Criterios

• I / O es a través de stdin / stdout.
• La longitud del programa se mide en bytes.
• Los programas consisten solo en caracteres imprimibles ASCII.
• No debe haber duplicados entre los programas P, P ₁ , ..., P _n .

EDITAR: Los programas P, P ₁ , ..., P _n están destinados a ser código fuente, y "ejecutar el programa" se refiere a cualquier procesamiento que produzca la salida (es decir, interpretación, compilación y ejecución, etc.).

Golfscript 39 14

~'Hello!'{`}@*

Ejemplo:

Suponiendo que n = 4 y nuestro programa es P , estos son los pasos:

1. Ejecute P con el parámetro 4 . La salida es "\"\\\"\\\\\\\"Hello!\\\\\\\"\\\"\""( P ₁ )

2. Ejecución _de salidas P ₁"\"\\\"Hello!\\\"\"" ( P ₂ )

3. Ejecución _de salidas P ₂"\"Hello!\"" ( P ₃ )

4. Ejecución _de salidas P ₃"Hello!" ( P ₄ )

5. Ejecutando salidas P ₄Hello! . Si no confías en mí, sigue este enlace ☺.

JavaScript, 58 caracteres

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

Perl ( 45 36)

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

Ejecutar con perl -M5.010para usar say.

For n=1, salidas say q(Hello!)
For n=2, salidas say q(say q(Hello!))
For n=3, salidas, say q(say q(say q(Hello!)))
etc.

Python3, 66

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

Lisp común, 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)))

Lo único que no es sencillo: genera un nivel de programa más de lo necesario y lo evalúa, porque evales un carácter más corto que print.

Lisp común: 65

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

Esta versión es más pequeña que la respuesta CL existente. En caso de que su Lisp croe con un stackoverflow, entonces tiene que usar esto, 81 bytes:

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

Sé que llego tarde a la fiesta, y estoy seguro de que esto aún podría optimizarse.

Demostración (cuidado, algunos REPL en línea no funcionan correctamente):

* #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!"
* 

Tenga en cuenta que:

• Probado con SBCL 1.2.11.debian

• Hay muchas advertencias porque estoy haciendo cosas que, en serio, no deberían hacerse. Afortunadamente, todas las advertencias se imprimen con un punto y coma, por lo que se tratarán como comentarios de todos modos.

• La duplicación se debe a que uno es el valor de retorno y una salida real. Si el valor de retorno también cuenta, entonces se simplifica a 58 bytes:#1=(SETF N(READ)(CADDR'#1#)(1- N)W(IF(= N 0)"Hello!"'#1#))

• Todavía sé que llego tarde a la fiesta

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 o 12 (si uso golfbash)

Código:

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

código de golfbash:

R;n e Hello!

Código anterior (49):

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

Utilizar:

Hacer programa P

$ echo '<paste code here>' > P

$ chmod +x P

Ejemplo

Hacer P1:

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

Hacer P2:

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

Hacer P3:

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

Hacer P4:

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

Ejecute P4:

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

Digamos que creo un nuevo lenguaje de propósito general llamado golfbash, un poco como golfscript, que tiene algunos comandos útiles como estos:

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.

Entonces podría escribir esto:

R;n e Hello!

Esto sería legal, ¿no?

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

Tenga en cuenta que J usa cadenas de estilo Pascal: 'It''s too easy!'

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

Explicado:

• ".1!:1]1 - Leer en una línea de stdin y convertirlo en un número.
• <:2^ - Lleva 2 a la potencia de este número y disminuye.
• ''''#~ - Haga una cadena con tantas copias del carácter de comillas simples.
• 'Hello!'(],,)- Agregue estas citas al frente y al reverso 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())

Golf por primera vez, no estoy seguro si lo estoy haciendo bien; p

Clojure, 36 bytes

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

Símbolo

'something

evalúa a

something

Cree un símbolo con 5 comillas simples y ejecute el resultado hasta que no queden comillas.