Program that outputs a program that outputs a program ... that outputs "Hello!"

Question

Challenge

Write the shortest program P such that

• P takes any positive integer n as input, and outputs a program string P₁

• executing P₁ (with no input) outputs a program string P₂,

• executing P₂ (with no input) outputs a program string P₃,

• ...

• executing P_n (with no input) outputs exactly "Hello!" (without the quotes).

Schematically:

                P(n) → P₁ → P₂ → ... → P_n → Hello!

Criteria

• I/O is via stdin/stdout.
• Program length is measured in bytes.
• Programs consist only of ASCII printable characters.
• There must be no duplicates among the programs P, P₁,...,P_n.

EDIT: Programs P, P₁,...,P_n are meant to be source code, and "executing the program" refers to whatever processing produces the output (i.e., interpretation, compilation & execution, etc.).

Answer 1

Golfscript 39 14

~'Hello!'{`}@*

Example:

Assuming that n=4 and our program is P, these are the steps:

1. Run P with parameter 4. The output is "\"\\\"\\\\\\\"Hello!\\\\\\\"\\\"\"" (P₁)

2. Running P₁ outputs "\"\\\"Hello!\\\"\"" (P₂)

3. Running P₂ outputs "\"Hello!\"" (P₃)

4. Running P₃ outputs "Hello!"(P₄)

5. Running P₄ outputs Hello!. If you don't trust me, follow this link ☺.

Answer 2

JavaScript, 58 chars

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

Answer 3

Perl (45 36)

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

Run with perl -M5.010 to use say.

For n=1, outputs say q(Hello!)
For n=2, outputs say q(say q(Hello!))
For n=3, outputs say q(say q(say q(Hello!)))
and so on.

Answer 4

Python3, 66

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

Answer 5

Common Lisp, 68 characters

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

The only non-straightforward thing: it generates one more level of program than needed and evaluates it, because eval is one character shorter than print.

Answer 6

Common Lisp: 65

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

This version is smaller than the existing CL-answer. In case your Lisp croaks with a stackoverflow, then you have to use this, 81 bytes:

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

I know I'm late to the party, and I'm sure this could still be optimized.

Demonstration (careful, some online REPLs don't work correctly):

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

Note that:

• Tested using SBCL 1.2.11.debian

• There are lots of warnings because I'm doing things that are seriously not supposed to be done. Thankfully, all warnings are printed with a semi-colon, so they would be treated as comments anyway.

• Duplication is because one is the return value and one actual output. If the return value would also count, then it simplifies to 58 bytes: #1=(SETF N(READ)(CADDR'#1#)(1- N)W(IF(= N 0)"Hello!"'#1#))

• I still know I'm late to the party

Answer 7

Python 2.7, 57

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

Answer 8

Haskell, 62

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

Answer 9

Bash, 47 or 12 (if I use golfbash)

Code:

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

golfbash code:

R;n e Hello!

Previous code (49):

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

Use:

Make program P

$ echo '<paste code here>' > P

$ chmod +x P

Example

Make P1:

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

Make P2:

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

Make P3:

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

Make P4:

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

Run P4:

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

Say that I make a new general purpose language called golfbash - at bit like golfscript - that has some useful commands like these:

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.

Then I could write this:

R;n e Hello!

This would be legal, would't it?

Answer 10

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

Answer 11

J - 31 char

Keep in mind that J uses Pascal-style strings: 'It''s too easy!'

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

Explained:

• ".1!:1]1 - Read in a line from stdin and convert it to a number.
• <:2^ - Take 2 to the power of this number, and decrement.
• ''''#~ - Make a string with that many copies of the single quote character.
• 'Hello!'(],,) - Append these quotes to the front and back of Hello!.

Usage:

   '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!

Answer 12

Python 2.7: 75

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

First time golfing, not sure if I'm doing it right ;p

Answer 13

Clojure, 36 bytes

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

Symbol

'something

evaluates to

something

Build up a symbol with 5 single quotes and run the result until no quotes left.