Các thách thức

Trong thử thách này, bạn chỉ định ngôn ngữ nguồn S và ngôn ngữ đích T . Nhiệm vụ của bạn là viết chương trình sau Pbằng ngôn ngữ S. Nếu một chương trình hợp lệ Qtrong ngôn ngữ Tđược cung cấp làm đầu vào P, nó sẽ xuất ra một chương trình hợp lệ Rbằng ngôn ngữ Tkhông có đầu vào và đầu ra Q(R), nghĩa là chương trình Qđược áp dụng cho mã nguồn của R. Ngoài ra , bạn nên trình bày trong câu trả lời của mình một chương trình ví dụ không cần thiết Q(càng thú vị, càng tốt, mặc dù bạn không ghi được điểm nào cho việc này), chương trình kết quả Rvà đầu ra của R. Đây là mã golf, vì vậy mã ngắn nhất để Pgiành chiến thắng.

Nói cách khác, đây là một thách thức về việc viết một "hàm tạo quine phổ quát" có thể tạo ra các kiểu khai thác tổng quát tùy ý.

Làm rõ

• Ngôn ngữ nguồn và đích của bạn có thể giống hệt nhau.
• Chương trình Pnên lấy một chuỗi làm đầu vào (từ STDIN hoặc tương đương) và xuất một chuỗi (sang STDOUT hoặc tương đương), như mọi chương trình đầu ra R.
• Các chương trình đầu vào Qcũng nên chuyển đổi một chuỗi thành một chuỗi khác, nhưng hình thức của chúng linh hoạt hơn: chúng có thể là các hàm chuỗi thành chuỗi, đoạn mã sửa đổi một biến với một tên nhất định, đoạn mã sửa đổi ngăn xếp dữ liệu nếu ngôn ngữ đích của bạn có một, v.v. Bạn cũng có thể hạn chế hơn nữa hình thức của Qbằng cách nói rằng, ví dụ, chúng có thể không chứa bất kỳ nhận xét nào. Tuy nhiên, bạn phải có khả năng thực hiện bất kỳ chức năng chuỗi-chuỗi có thể tính toán nào dưới dạng một chương trình đầu vào Qvà bạn phải nêu rõ cách thức hoạt động của chúng và những hạn chế nào nữa mà bạn đặt lên chúng.
• Chương trình đầu ra Rphải thực sự là một quine (tổng quát), vì vậy nó không được đọc bất kỳ đầu vào nào (đầu vào của người dùng, tệp, v.v.) trừ khi Qlàm như vậy.
• Sơ hở tiêu chuẩn là không được phép.

Một ví dụ

Giả sử tôi chọn Python làm ngôn ngữ nguồn của mình và Haskell làm ngôn ngữ đích và tôi yêu cầu thêm rằng chương trình đầu vào phải là định nghĩa một dòng của String -> Stringhàm có tên f. Nếu tôi đưa ra chương trình đảo ngược chuỗi

f x = reverse x

làm đầu vào cho chương trình Python của tôi P, nó sẽ xuất mã nguồn của chương trình Haskell khác R. Chương trình này in ra STDOUT mã nguồn của R, nhưng bị đảo ngược. Nếu Pđược cung cấp chức năng nhận dạng

f x = x

là đầu vào, chương trình đầu ra Rlà một quine.

Nguồn = Target = CJam, 19 17 16 byte

{`"_~"+}`)q\"_~"

Điều này giả định rằng chương trình đầu vào Q(được đưa ra trên STDIN) là một đoạn mã CJam dự kiến ​​một chuỗi trên đỉnh của ngăn xếp và để lại một chuỗi khác trên đầu ngăn xếp.

Kiểm tra nó ở đây.

Ví dụ

1. Danh tính sẽ chỉ là một đoạn mã rỗng, do đó, để lại các bản in trống STDIN

   {`"_~"+}_~
   

   Đó là quine tiêu chuẩn, với một bổ sung +.

2. Để đảo ngược một chuỗi trong CJam, bạn có thể sử dụng W%, do đó, đặt chuỗi đó lên STDIN, điều này mang lại:

   {`"_~"+W%}_~
   

   mà chúng ta có thể chạy để có được

   ~_}%W+"~_"`{
   

3. Như một ví dụ thứ ba, giả sử chúng ta sử dụng một đoạn mã xen kẽ một chuỗi với khoảng trắng : ' *. Chạy Pvới đó là đầu vào, chúng tôi nhận được

   {`"_~"+' *}_~
   

   lần lượt in

   { ` " _ ~ " + '   * } _ ~  
   

4. Bây giờ nó cũng hoạt động nếu Qcó ngắt dòng (mặc dù điều đó không bao giờ cần thiết trong CJam). Đây là một chương trình có ngắt dòng, loại bỏ tất cả các ngắt dòng khỏi chuỗi (theo cách phức tạp không cần thiết - chia thành các dòng, sau đó nối):

   N/
   ""
   *
   

   Điều này dẫn đến kết quả như sau R:

   {`"_~"+N/
   ""
   *}_~
   

   lần lượt in

   {`"_~"+N/""*}_~
   

Giải trình

Trước tiên hãy xem sản lượng được sản xuất:

Tiêu chuẩn của CJam là

{`"_~"}_~

Nó hoạt động như sau:

• Đẩy khối {`"_~"}.
• Nhân đôi nó với _.
• Thực hiện các bản sao với ~.
• Bây giờ bên trong khối, `biến khối đầu tiên thành biểu diễn chuỗi của nó.
• "_~" đẩy hai ký tự của nguồn không phải là một phần của khối (và do đó bị thiếu trong biểu diễn chuỗi).
• Hai chuỗi được in ngược trở lại vào cuối chương trình.

^{Trong câu hỏi cơ bản, điều `này là không cần thiết, bởi vì nếu bạn chỉ để nguyên khối, nó sẽ được in giống nhau ở cuối chương trình.}

Đầu ra của chương trình của tôi Plà phiên bản sửa đổi của đoạn mã này. Đầu tiên, tôi đã thêm một +khối vào đó, nối hai chuỗi thành một chuỗi chứa toàn bộ nguồn. Lưu ý rằng điều này sẽ đúng cho dù tôi làm gì trong khối, bởi vì tất cả sẽ được thêm vào biểu diễn chuỗi thu được với `. Bây giờ tôi chỉ có thể đặt chương trình / đoạn mã Qbên trong khối sau +, để nó có thể sửa đổi chuỗi nguồn trước khi nó được in. Một lần nữa, vì Qđi vào bên trong khối, nó sẽ là một phần của chuỗi nguồn đã nói.

Tóm lại, Pbản in

{`"_~"+Q}_~

Bây giờ, về cách tôi đi xây dựng đầu ra này trong P:

{`"_~"+}         "Push the block without Q.";
        `        "Turn it into a string. This is shorter than writing a string right away,
                  because I'd have to escape the quotes, and I'd need two quotes instead of
                  one backtick.";
         )       "Pop off the last character (the brace) and push it on the stack.";
          q      "Read input Q.";
           \     "Swap Q with the brace.";
            "_~" "Push the final two characters.";

Bốn chuỗi được in tự động (back-to-back) ở cuối chương trình.

Biểu thức Haskell → Biểu thức Haskell, 41 byte

((++)<*>show).('(':).(++")$(++)<*>show$")

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

P $ "Q"= ((++)<*>show).('(':).(++")$(++)<*>show$") $ "Q"cấu trúc "R"bởi

1. (++")$(++)<*>show$"): Phụ thêm chuỗi ")$(++)<*>show$",
2. ('(':): chuẩn bị nhân vật '(', và
3. (++)<*>show(= \x->x++show x): nối thêm phiên bản được trích dẫn đó,

dẫn đến "R"= "(Q)$(++)<*>show$\"(Q)$(++)<*>show$\"".

R= (Q)$(++)<*>show$"(Q)$(++)<*>show$"hoạt động bởi

1. lấy chuỗi "(Q)$(++)<*>show$",
2. (++)<*>show: nối thêm một phiên bản được trích dẫn đó,
3. áp dụng Qvào đó,

dẫn đến Q "(Q)$(++)<*>show$\"(Q)$(++)<*>show$\""= Q "R".

(Các parens xung quanh Qlà cần thiết bởi vì Qcó thể chứa $dễ dàng như Rvậy, và $không may là liên kết đúng.)

Bản giới thiệu

λ> putStrLn $ ((++)<*>show).('(':).(++")$(++)<*>show$") $ "id"
(id)$(++)<*>show$"(id)$(++)<*>show$"
λ> putStrLn $ (id)$(++)<*>show$"(id)$(++)<*>show$"
(id)$(++)<*>show$"(id)$(++)<*>show$"
λ> putStrLn $ ((++)<*>show).('(':).(++")$(++)<*>show$") $ "reverse"
(reverse)$(++)<*>show$"(reverse)$(++)<*>show$"
λ> putStrLn $ (reverse)$(++)<*>show$"(reverse)$(++)<*>show$"
"$wohs>*<)++($)esrever("$wohs>*<)++($)esrever(
λ> putStrLn $ ((++)<*>show).('(':).(++")$(++)<*>show$") $ "length"
(length)$(++)<*>show$"(length)$(++)<*>show$"
λ> print $ (length)$(++)<*>show$"(length)$(++)<*>show$"
44

Nguồn = Target = JavaScript, 66

console.log("function a(){console.log("+prompt()+"(a+'a()'))}a()")

Giả định cho Q:

• Q phải là một hàm ẩn danh JavaScript chuỗi-chuỗi.

Ví dụ:

• Đảo ngược . Q =function(s) { return s.split('').reverse().join(''); }

Trong trường hợp này, P(Q)(hoặc R) sẽ là:function a(){console.log(function(s) { return s.split('').reverse().join(''); }(a+'a()'))}a() , và bằng cách thực hiện nó, chúng ta sẽ nhận được: )(a}))')(a'+a(} ;)''(nioj.)(esrever.)''(tilps.s nruter { )s(noitcnuf(gol.elosnoc{)(a noitcnufnó hoàn toàn giống như Q(R).

• Danh tính . Q =function(s) { return s; }

trong trường hợp này, P(Q)(hoặc R) sẽ là: function a(){console.log(function(s) { return s; }(a+'a()'))}a()đó là Quine JavaScript . Không cần phải nói, Q(R)sẽ giống nhau, vì Q là hàm Nhận dạng.

Một số lưu ý:

STDIN trong JavaScript theo truyền thống prompt(), tuy nhiên, tôi đã cho phép bản thân tránh xa truyền thống alert()là STDOUT, để làm cho quá trình chạy đầu ra như một chương trình sử dụng sao chép dễ dàng hơn. (Tôi nhận ra mình có thể lưu tối đa 12 ký tự khi thay đổi thành alert()).

Tôi cũng có thể làm mọi thứ ngắn hơn nhiều trong ES6, nhưng bây giờ tôi muốn ở lại với JavaScript nguyên bản. Tôi đang xem xét gửi câu trả lời S = Scala, T = ECMA6 trong tương lai, chỉ để trải nghiệm.

Tôi cũng nhận ra rằng JavaScript gần như không bao giờ có thể đánh bại được CJam trong môn đánh gôn , nhưng tôi đã phải thực hiện thử thách này! Đó chắc chắn là một niềm vui.

Jelly → 7 , 9 byte

“ṚƓ^ṾṂ’³3

Hãy thử trực tuyến!

Q là một hàm 7 (nghĩa là không nhìn ra ngoài phần tử ngăn xếp trên cùng và I / O thông qua ngăn xếp) và được đưa ra dưới dạng đối số dòng lệnh.

Giải trình

Chương trình 7

Hàm tạo quine phổ biến trong 7 mà tôi sử dụng ở đây là:

717162234430…3

Điều đầu tiên cần lưu ý là phần 7 hàng đầu tương đương với khoảng trắng hàng đầu và không có bất kỳ ảnh hưởng nào đến chương trình. Lý do duy nhất là nó phải tuân theo các quy tắc của PPCG đối với các nguyên tắc chỉ theo nghĩa đen (nó được mã hóa bởi thứ hai 1trong chương trình chứ không phải chính nó).

Phần còn lại của chương trình là một phần tử ngăn xếp đơn (nó có 7s và s cân bằng 6), thực hiện như sau khi chạy:

717162234430…3
 1716           Push a stack element "7" onto the stack
     2          Copy it
      23        Pop and output one of the copies (selecting format 7)
        4430    Prepend it to the top of stack
             3  Output it

Nói cách khác, phần tử ngăn xếp này là một chương trình in phần trên cùng của ngăn xếp, với 7định dạng đầu ra 7 (có nghĩa là "in theo nghĩa đen, sử dụng cùng một mã hóa như mã nguồn", và do đó rõ ràng là mã hóa tốt nhất cho quines). Ở đây khá may mắn là chúng ta có thể sử dụng lại nghĩa đen 7cho hai mục đích (định dạng đầu ra và khoảng trắng hàng đầu.) Rõ ràng, bằng cách chèn một cái gì đó ngay trước trận chung kết 3, chúng ta có thể xuất ra một chức năng 7+ đầu vào, thay vì chỉ xuất ra 7và đầu vào trực tiếp.

Làm thế nào để phần tử ngăn xếp này có được tại mã nguồn của chính nó? Chà, khi kết thúc chương trình, 7 evalphần tử ngăn xếp trên cùng theo mặc định. Tuy nhiên, nó không thực sự xuất hiện từ ngăn xếp trong quá trình, vì vậy phần tử stack theo nghĩa đen được evaldẫn vẫn còn đó. (Nói cách khác, chương trình không đọc nguồn của chính nó - bằng chứng là thực tế là nó không thể nhìn thấy 7khi bắt đầu chương trình, đó là một dấu tách phần tử ngăn xếp chứ không phải là một phần của nghĩa đen - mà là, nó bao gồm chủ yếu là một nghĩa đen được evaldẫn theo mặc định.)

Chương trình Jelly

Đây có lẽ là một trong những chương trình Jelly ít giống Jelly nhất mà tôi đã viết; nó bao gồm ba nilads ( “ṚƓ^ṾṂ’, ³, 3), mà chỉ là đầu ra theo thứ tự vì không có hoạt động được thực hiện trên chúng. Các 3là đủ rõ ràng, chỉ là một hằng số nguyên. Không³ này cũng đơn giản nếu bạn biết Jelly: đó là ký hiệu rõ ràng của Jelly cho đối số dòng lệnh đầu tiên (đó là nơi Jelly thường lấy đầu vào của nó). Phần còn lại của chương trình Jelly đại diện cho phần lớn 7 công cụ xây dựng quine phổ quát của tôi: bằng cách khai thác thực tế là tất cả các lệnh trong 7 có thể được biểu diễn bằng các chữ số ASCII, chúng ta có thể diễn giải717162234430không phải là một chuỗi các lệnh, hoặc thậm chí là một số bát phân (giống như về mặt khái niệm), mà là một số thập phân, có nghĩa là chúng ta không cần bất kỳ định dạng đặc biệt nào cho đầu ra. Số thập phân đó trở thành “ṚƓ^ṾṂ’ký hiệu số nguyên nén của Jelly.

Thí dụ

Nếu chúng tôi cung cấp 24053dưới dạng chương trình Q, chúng tôi sẽ nhận được đầu ra sau:

717162234430240533

Hãy thử trực tuyến!

2405 nối phần tử ngăn xếp trên cùng với chính nó:

2405   Stack   Explanation
       x
2      x|x     Duplicate top of stack
 4     x||x    Swap two stack elements, with an empty element between
  0    x|(X)   Escape the top stack element, then concatenate the top two
   5   xx      Execute the top stack element

(Bước cuối cùng có vẻ hơi khó hiểu; những gì đang xảy ra là việc thoát một phần tử ngăn xếp sẽ chuyển đổi từng lệnh trong đó từ "chạy lệnh này" thành "nối lệnh này lên đầu ngăn xếp", vì vậy mỗi lệnh sẽ tự thêm vào bản gốc phần tử ngăn xếp trên cùng khi nó chạy.)

Như vậy, chạy chương trình kết quả R cung cấp cho chúng ta hai bản sao của R:

7171622344302405371716223443024053

CJam → CJam, 13 byte

{`"_~"+7}_~qt

Hãy thử trực tuyến!

Đầu vào Qphải là một đoạn mã sửa đổi chuỗi duy nhất trong ngăn xếp. Qđược đọc từ stdin.

Thí dụ

Đầu vào:

S*W%

Nó thêm một khoảng trắng giữa mỗi hai ký tự và đảo ngược chuỗi.

Đầu ra:

{`"_~"+S*W%}_~

Đầu ra của quine tổng quát:

~ _ } % W * S + " ~ _ " ` {

Giải trình

{`"_~"+7}_~      e# Evaluate a generalized quine in CJam that only appends a 7.
q                e# Read the input.
t                e# Replace the 7th character (0-based) with the input.

Đầu tiên, nó đánh giá quine, vì vậy chúng ta có thể nhận được biểu diễn chuỗi của nó mà không cần trích dẫn kép không cần thiết. Sau đó thay thế tải trọng với đầu vào.

Nó có thể là {`"_~"+ }_~7qtnơi không gian là nơi giữ chỗ của tải trọng. Nhưng thay đổi tải trọng để 7tiết kiệm một byte.

Than → Perl (5), 29 33 byte

Ａ$_=q(αＡ);evalβαＳ"\α$_β\n";printβ

Hãy thử trực tuyến!

Chương trình Perl Q sẽ trả về một đoạn mã nhận đầu vào dưới dạng một chuỗi ở phía bên phải của nó và cung cấp đầu ra trong biến $_. (Các hàm Perl tùy ý có thể được chuyển đổi sang dạng này thông qua việc gói chúng dưới dạng sub x {…}; $_=x. Trong hầu hết các trường hợp, cú pháp của Perl có nghĩa là không yêu cầu gói.)

Giải trình

Perl

Đây là những gì các nhà xây dựng quine Perl phổ quát trông giống như:

$_=q(…"\$_=q($_);eval";print);eval

(Trong hầu hết các trường hợp bạn muốn chơi golf này $_=q(say…"\$_=q($_);eval");eval, nhưng tôi không chắc bạn có thể đặt mã Perl tùy ý vào …đó không.)

Nói cách khác, chúng ta có một trình bao bọc bên ngoài $_=q(…);evalgán một chuỗi $_và sau đó đánh giá nó. Bên trong trình bao bọc "\$_=q($_);eval", nghĩa là tái cấu trúc trình bao cùng với nội dung của nó thông qua việc sử dụng giá trị chúng tôi lưu trữ $_, cộng với mã Q do người dùng chỉ định, cộng với printđể in đầu ra. (Thật không may, chúng tôi không thể sử dụng say; nó thêm một dòng mới và có liên quan trong các câu hỏi.)

Than

"Điểm" của câu trả lời này là tạo ra các câu hỏi tổng quát trong Perl, vì vậy một khi tôi đã có một chiến lược chơi gôn để thực hiện điều đó (tôi đã sử dụng trong nhiều câu trả lời khác), đã đến lúc viết chương trình P, về cơ bản chỉ là thay thế một chuỗi thành một mẫu. Điều tôi muốn ở đây là một ngôn ngữ tốt trong việc in các chuỗi không đổi (lý tưởng là nén chúng một chút) và nội suy người dùng nhập vào chúng.

Sau khi thử một vài thứ, tôi đã giải quyết được Than, thứ mà tôi chưa từng sử dụng trước đây (và điều này thực sự có thể làm với một số tài liệu); nó được thiết kế cho nghệ thuật ASCII nhưng cũng có khả năng viết các chuỗi theo một chiều. Các ký tự ASCII được in theo nghĩa đen trong Char than, có nghĩa là việc in các chuỗi không đổi không cần soạn thảo và chúng ta có thể sử dụng Ｓlệnh để nội suy một chuỗi được lấy từ đầu vào của người dùng vào chương trình.

Tuy nhiên, có thể đi ngắn hơn một chút. Hàm tạo quine phổ biến Perl chứa hai phần lặp lại khá dài. Do đó, chúng ta có thể sử dụng Ａlệnh để gán chúng cho các biến (ví dụ: Ａ…αgán cho biến α) và chỉ cần nội suy các biến vào chuỗi chúng ta đang in thông qua việc sử dụng tên của chúng. Điều đó tiết kiệm một vài byte chỉ bằng cách viết chuỗi theo nghĩa đen.

Thật không may, Char than cũng bổ sung một dòng mới vào chương trình, nhưng đó không phải là một vấn đề lớn; nó chỉ đơn giản tốn hai byte cho một \nđể thêm dòng mới đó vào đầu vào của Q.

Thí dụ

Nếu chúng ta đưa ra đầu vào $_=reverse(đảo ngược một chuỗi), chúng ta sẽ nhận được đầu ra sau:

$_=q($_=reverse"\$_=q($_);eval\n";print);eval

Hãy thử trực tuyến!

đó là một quine-alike in ngược nguồn của nó, như mong đợi.

Jelly → Tải trọng , 15 byte

“(a(:^)*“S):^”j

Hãy thử trực tuyến!

Lấy hàm Underload đầu vào Q làm đối số giống như lệnh. Q phải lấy đầu vào từ ngăn xếp và đẩy đầu ra vào ngăn xếp, mà không cố kiểm tra các phần tử ngăn xếp sâu hơn (vì chúng sẽ không tồn tại).

Giải trình

Tải trọng

Hàm tạo quine phổ biến dưới tải được sử dụng ở đây là:

(a(:^)*…S):^

Hầu hết các chương trình là một chữ duy nhất. Chúng tôi theo đó bằng cách :^sao chép nó, sau đó đánh giá một bản sao (để lại bản sao khác trên ngăn xếp).

Khi bắt đầu literal đánh giá, chúng tôi chạy a(escape, mang nó trở lại thành dạng giống như Programa gốc), và (:^)*(có gắn thêm :^), do đó xây dựng lại mã nguồn cho toàn bộ chương trình. Sau đó chúng ta có thể chạy hàm Q để biến đổi hàm này theo cách tùy ý và in kết quả bằngS .

Thạch

Tôi không thể sử dụng Char than lần này vì trình thông dịch Underload xác thực gặp sự cố ở cuối chương trình nếu chương trình kết thúc với một dòng mới. (Một số trình thông dịch Underload, chẳng hạn như phiên dịch trên TIO, không thực thi quy tắc này, nhưng tôi muốn có thể mang theo đúng cách.) Thật không may, Char than tự nhiên thêm các dòng mới vào đầu ra của nó. Thay vào đó, tôi đã sử dụng Jelly, gần như là ngắn gọn trong những trường hợp đơn giản như thế này; chương trình bao gồm một danh sách bằng chữ với hai phần tử ( ““”) và nối chúng với đầu vào ( j), do đó nội suy đầu vào của người dùng vào chương trình.

Thí dụ

Sử dụng đầu vào :S^(in một bản sao, sau đó đánh giá bản gốc), chúng tôi nhận được chương trình Tải trọng sau:

(a(:^)*:S^S):^

Hãy thử trực tuyến!

Điều này tự in vô hạn nhiều lần, theo một cách khá thú vị: sau khi thực hiện hành vi quine bình thường, sau đó nó chạy evaltrên một bản sao của những gì nó xuất ra. Điều đó làm cho toàn bộ chương trình được xây dựng lại chạy lại vô thời hạn (Underload là đệ quy đuôi). Tự kiểm tra bản thân và thực hiện một cách evalthực sự là cách duy nhất để thực hiện một vòng lặp vô hạn trong Underload.

RProgN 2 , 11 byte

'{`{.%s}{'F

Giải thích chương trình

'{`{.%s}{'F
'{`{.%s}{'  # Push the string "{`{.%s}{" to the stack.
          F # Format the input with the top of the stack as a template. Which produces {`{.<INPUT>}{

Giải thích

Quine được sản xuất rất đơn giản, nhưng sử dụng chức năng của các trình xử lý chức năng chưa từng có trong RProgN2 để tạo ra một quine ngắn và ngọt, được gọi là quine "Looping". Đó là một khái niệm tương tự đáng ngạc nhiên với một <> <quine.

{`{.}{
{`{.}   # Push the function {`{.} to the stack.
     {  # Try to define a new function, fail, loop back to index 1. (Which in turn, skips the function definition.)
 `{     # Push the string "{" to the stack.
   .    # Concatenate the top two values of the stack, which stringifies the function, then appends { to it.
    }   # Try to terminate a function, fail quietly, and terminate the program.

Tất nhiên, do cấu trúc của quine này, bất cứ thứ gì ngoại trừ các no-op thực sự (Không được xâu chuỗi) đều có thể được đặt sau hàm concatenate, và

Một số quines

• {`{.i}{: Đầu ra {}i.{`{. ichỉ là chức năng "nghịch đảo", do đó chương trình này tự đảo ngược.
• {`{.S§.}{: Đầu ra ..S`{{{}§. Schuyển đổi chuỗi thành một chồng các ký tự, §sắp xếp ngăn xếp theo từ vựng, sau đó .nối nó lại với nhau, xuất ra chính nó được sắp xếp.

Hãy thử trực tuyến!