Thử thách

Viết chương trình P ngắn nhất sao cho

• P lấy bất kỳ số nguyên dương n nào làm đầu vào và xuất ra chuỗi chương trình P ₁

• thực thi P ₁ (không có đầu vào) tạo ra chuỗi chương trình P ₂ ,

• thực thi P ₂ (không có đầu vào) tạo ra chuỗi chương trình P ₃ ,

• ...

• thực thi P _n (không có đầu vào) đầu ra chính xác "Xin chào!" (không có dấu ngoặc kép).

Sơ đồ:

                P (n) → P ₁ → P ₂ → ... → P _n → Xin chào!

Tiêu chí

• I / O là thông qua stdin / stdout.
• Độ dài chương trình được đo bằng byte.
• Các chương trình chỉ bao gồm các ký tự có thể in ASCII.
• Không được trùng lặp giữa các chương trình P, P ₁ , ..., P _n .

EDIT: Các chương trình P, P ₁ , ..., P _n có nghĩa là mã nguồn và "thực thi chương trình" đề cập đến bất kỳ quá trình xử lý nào tạo ra đầu ra (nghĩa là giải thích, biên dịch và thực thi, v.v.).

Golfscript 39 14

~'Hello!'{`}@*

Thí dụ:

Giả sử n = 4 và chương trình của chúng tôi là P , đây là các bước:

1. Chạy P với tham số 4 . Đầu ra là "\"\\\"\\\\\\\"Hello!\\\\\\\"\\\"\""( P ₁ )

2. Chạy đầu ra P ₁"\"\\\"Hello!\\\"\"" ( P ₂ )

3. Chạy đầu ra P ₂"\"Hello!\"" ( P ₃ )

4. Chạy đầu ra P ₃"Hello!" ( P ₄ )

5. Chạy đầu ra P ₄Hello! . Nếu bạn không tin tưởng tôi, hãy theo liên kết này .

JavaScript, 58 ký tự

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

Perl ( 45 36)

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

Chạy với perl -M5.010để sử dụng say.

Đối với n=1, đầu ra say q(Hello!)
Cho n=2, đầu ra say q(say q(Hello!))
Cho n=3, đầu ra say q(say q(say q(Hello!)))
và như vậy.

Python3, 66

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

Lisp thông thường, 68 ký tự

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

Điều duy nhất không đơn giản: nó tạo ra một cấp độ chương trình nhiều hơn mức cần thiết và đánh giá nó, bởi vì evalnó ngắn hơn một ký tự print.

Lisp thường gặp: 65

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

Phiên bản này nhỏ hơn câu trả lời CL hiện có. Trong trường hợp Lisp của bạn bị lừa với luồng stackover, thì bạn phải sử dụng cái này, 81 byte:

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

Tôi biết tôi đến bữa tiệc muộn và tôi chắc chắn điều này vẫn có thể được tối ưu hóa.

Trình diễn (cẩn thận, một số REPL trực tuyến không hoạt động chính xác):

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

Lưu ý rằng:

• Đã thử nghiệm bằng SBCL 1.2.11.debian

• Có rất nhiều cảnh báo bởi vì tôi đang làm những việc nghiêm túc không nên làm. Rất may, tất cả các cảnh báo được in bằng dấu chấm phẩy, vì vậy chúng sẽ được coi là nhận xét.

• Sao chép là bởi vì một là giá trị trả về và một đầu ra thực tế. Nếu giá trị trả về cũng sẽ được tính, thì nó đơn giản hóa thành 58 byte:#1=(SETF N(READ)(CADDR'#1#)(1- N)W(IF(= N 0)"Hello!"'#1#))

• Tôi vẫn biết tôi đến bữa tiệc muộn

Con trăn 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 hoặc 12 (nếu tôi sử dụng golfbash)

Mã số:

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

mã golfbash:

R;n e Hello!

Mã trước (49):

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

Sử dụng:

Lập chương trình P

$ echo '<paste code here>' > P

$ chmod +x P

Thí dụ

Tạo P1:

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

Kiếm P2:

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

Tạo P3:

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

Tạo P4:

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

Chạy P4:

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

Giả sử tôi tạo một ngôn ngữ có mục đích chung mới gọi là golfbash - giống như golfscript - có một số lệnh hữu ích như sau:

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.

Sau đó tôi có thể viết điều này:

R;n e Hello!

Điều này sẽ hợp pháp, phải không?

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

Hãy nhớ rằng J sử dụng các chuỗi kiểu Pascal: 'It''s too easy!'

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

Giải thích:

• ".1!:1]1 - Đọc trong một dòng từ stdin và chuyển đổi nó thành một số.
• <:2^ - Lấy 2 đến sức mạnh của số này và giảm dần.
• ''''#~ - Tạo một chuỗi với nhiều bản sao của ký tự trích dẫn.
• 'Hello!'(],,)- Nối các trích dẫn này vào mặt trước và mặt sau của Hello!.

Sử dụng:

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

Con trăn 2.7: 75

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

Lần đầu chơi golf, không chắc là tôi có làm đúng không; p

Clojure, 36 byte

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

Biểu tượng

'something

đánh giá

something

Xây dựng một biểu tượng với 5 dấu ngoặc đơn và chạy kết quả cho đến khi không còn dấu ngoặc kép.