Trong thử thách này, người dùng sẽ lần lượt hoàn thành ba nhiệm vụ mã hóa khá đơn giản bằng các ngôn ngữ lập trình được phép tiến bộ cũ hơn.

Câu trả lời đầu tiên phải sử dụng ngôn ngữ lập trình được thực hiện trong năm 2015. Một khi có ít nhất một câu trả lời từ ngôn ngữ 2015, câu trả lời có thể sử dụng ngôn ngữ lập trình được thực hiện vào năm 2014. Tương tự, câu trả lời sử dụng ngôn ngữ từ năm 2013 không được phép cho đến khi có ít nhất một câu trả lời năm 2014

Nói chung, không được phép sử dụng ngôn ngữ lập trình từ năm Y cho đến khi câu trả lời sử dụng ngôn ngữ từ năm Y + 1 đã được gửi. Ngoại lệ duy nhất là Y = 2015.

Tìm ngôn ngữ của bạn

Để trả lời câu hỏi này, bạn phải biết năm mà ngôn ngữ lập trình của bạn được "thực hiện". Tất nhiên đây là một thuật ngữ chủ quan; một số ngôn ngữ đã được phát triển trong nhiều năm và nhiều ngôn ngữ vẫn đang được nâng cấp hàng năm. Hãy để năm mà một ngôn ngữ được "tạo ra" là năm đầu tiên việc triển khai ngôn ngữ đó xuất hiện trong công chúng.

Ví dụ, Python được "sản xuất" năm 1991 , mặc dù sự phát triển của nó đã được tiến hành từ năm 1989 và phiên bản 1.0 không được phát hành cho đến năm 1994.

Nếu năm nay vẫn chủ quan, chỉ cần sử dụng ý thức chung của bạn để chọn năm thích hợp nhất. Đừng sa lầy vào những bất đồng nhỏ về lựa chọn năm. Vui lòng cung cấp một liên kết đến một nguồn cho biết khi ngôn ngữ của bạn được thực hiện.

Các phiên bản hoặc tiêu chuẩn khác nhau của ngôn ngữ lập trình (ví dụ Python 1, 2, 3) được tính là cùng một ngôn ngữ với cùng một năm đầu tiên.

Vì vậy, trừ khi năm ngôn ngữ của bạn là 2015, bạn chỉ có thể gửi câu trả lời của mình sau khi câu trả lời đã được gửi mà năm của ngôn ngữ là năm ngay trước bạn.

Nếu câu trả lời hợp lệ cùng năm với câu trả lời của bạn đã tồn tại, thì bạn có thể trả lời. Không có vấn đề gì nếu ngôn ngữ của bạn được phát triển sớm hơn hoặc muộn hơn trong năm.

Nhiệm vụ

Bạn phải hoàn thành Nhiệm vụ 1 đến 3. Nhiệm vụ 0 là tùy chọn.

Các tác vụ này ít nhiều được chọn để tương ứng với ba khía cạnh quan trọng của lập trình: cung cấp đầu ra (Nhiệm vụ 1), lặp (Nhiệm vụ 2) và đệ quy (Nhiệm vụ 3).

Nhiệm vụ 0 - Lịch sử ngôn ngữ (tùy chọn)

Viết ít nhất một đoạn văn giải thích lịch sử của ngôn ngữ lập trình bạn đã chọn: ai đã phát triển nó, tại sao, như thế nào, v.v ... Điều này đặc biệt được khuyến khích nếu cá nhân bạn có mặt khi ngôn ngữ ra đời, và thậm chí có thể đóng vai trò trong sự phát triển của nó. Vui lòng liên hệ các giai thoại cá nhân về ảnh hưởng của ngôn ngữ đối với bạn hoặc công việc của bạn, hoặc bất cứ điều gì tương tự.

Nếu bạn còn quá trẻ để biết nhiều về lịch sử ngôn ngữ của bạn mà không cần nghiên cứu nhiều, hãy cân nhắc để lại một ghi chú cho người dùng lớn tuổi nói rằng họ có thể chỉnh sửa bài đăng của bạn và thêm vào một số lịch sử trực tiếp.

Nhiệm vụ 1 - "Xin chào, Thế giới!" Biến thể

Viết chương trình in

[language name] was made in [year made]!

đến khu vực đầu ra tiêu chuẩn của ngôn ngữ của bạn (thiết bị xuất chuẩn cho các ngôn ngữ gần đây nhất).

Ví dụ: nếu ngôn ngữ là Python, đầu ra sẽ là:

Python was made in 1991!

Nhiệm vụ 2 - ASCII Art N

Viết chương trình cho phép người dùng nhập số nguyên dương lẻ (bạn có thể cho rằng đầu vào luôn hợp lệ) và in ra một chữ cái nghệ thuật ASCII N được tạo bằng ký tự N.

Nếu đầu vào là 1, đầu ra là:

N

Nếu đầu vào là 3, đầu ra là:

N N
NNN
N N

Nếu đầu vào là 5, đầu ra là:

N   N
NN  N
N N N
N  NN
N   N

Nếu đầu vào là 7, đầu ra là:

N     N
NN    N
N N   N
N  N  N
N   N N
N    NN
N     N

Các mô hình tiếp tục như thế này. Đầu ra có thể chứa dấu cách.

Nhiệm vụ 3 - GCD

Viết chương trình cho phép người dùng nhập hai số nguyên dương (bạn có thể cho rằng đầu vào luôn hợp lệ) và in ước số chung lớn nhất của chúng . Đây được định nghĩa là số nguyên dương lớn nhất chia cả hai số mà không để lại phần dư. Nó có thể được tính toán dễ dàng bằng thuật toán Euclide .

Ví dụ:

8, 12→ 4
12, 8→ 4
3, 30→ 3
5689, 2→ 1
234, 876→6

Bạn có thể sử dụng chức năng tích hợp nhưng hãy thử tìm hiểu xem nó có ở phiên bản đầu tiên của ngôn ngữ của bạn không. Nếu không, hãy thử không sử dụng nó.

Quy tắc

• Bạn có thể trả lời nhiều lần, nhưng mỗi câu trả lời mới phải sử dụng một ngôn ngữ được thực hiện ít nhất 5 năm trước ngôn ngữ trong câu trả lời cuối cùng của bạn. Vì vậy, nếu bạn trả lời bằng ngôn ngữ 2015, bạn không thể trả lời lại cho đến khi ngôn ngữ 2010 được cho phép. Nếu bạn bắt đầu với câu trả lời năm 2010, bạn không thể thực hiện câu trả lời năm 2015 cho câu trả lời thứ hai của mình vì năm 2015 không phải trước năm 2010.
• Nếu có thể, hãy viết mã của bạn để nó có thể hoạt động trong phiên bản đầu tiên của ngôn ngữ của bạn (hoặc phiên bản cũ nhất có thể). (Đây không phải là một yêu cầu vì việc tìm kiếm trình biên dịch / phiên dịch cũ cho một số ngôn ngữ có thể khó khăn.)
• Không đăng một ngôn ngữ đã được đăng trừ khi câu trả lời được đăng có lỗi nghiêm trọng hoặc bạn có cách hoàn thành nhiệm vụ rất khác.
• Chơi golf mã của bạn là tốt nhưng không bắt buộc.
• Một dòng mới trong đầu ra của bất kỳ chương trình là tốt.
• Đối với các tác vụ 2 và 3, tất cả các giá trị đầu vào dưới một số tối đa hợp lý như 2 ¹⁶ sẽ hoạt động (ít nhất là 256).
• Ngôn ngữ của bạn phải tồn tại trước khi câu hỏi này được đăng.
• Các ngôn ngữ lập trình rất cũ có thể có các hình thức đầu vào và đầu ra khác với những gì chúng ta nghĩ ngày nay. Điều này là tốt Hoàn thành các nhiệm vụ hết khả năng của bạn trong ngữ cảnh ngôn ngữ của bạn.

Chấm điểm

Điểm số của bạn là:

upvotes - downvotes + (2015 - languageYear) / 2 

Do đó, 0,5 được thêm vào số phiếu bầu cho mỗi năm trước năm 2015, tạo lợi thế cho các ngôn ngữ cũ. Bài nộp với số điểm cao nhất sẽ thắng.

Danh sách trả lời

Đoạn mã dưới đây liệt kê tất cả các câu trả lời hợp lệ theo năm ngôn ngữ của họ.

Bạn phải bắt đầu bài đăng của mình với dòng Markdown này để đảm bảo nó được liệt kê chính xác:

#[year] - [language name]

Ví dụ:

#1991 - Python

Tên ngôn ngữ có thể nằm trong một liên kết (nó sẽ là cùng một liên kết trong danh sách trả lời):

#1991 - [Python](https://www.python.org/)

Câu trả lời không theo định dạng này hoặc có một năm chưa được phép hoặc đến từ người dùng đã trả lời trong 5 năm qua được đánh dấu là không hợp lệ.

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><script>$(function(){function e(e,r){var a="https://api.stackexchange.com/2.2/questions/48476/answers?page="+e.toString()+"&pagesize=100&order=asc&sort=creation&site=codegolf&filter=!YOKGPOBC5Yad160RQxGLP0r4rL";$.get(a,r)}function r(e){if(e.items.forEach(function(e){var r=e.link,a=e.owner.display_name,i=e.body.match(/<h1\b[^>]*>(\d{4}) - (.*?)<\/h1>/);if(i&&i.length>=3)var h=parseInt(i[1]),u=i[2];h&&u&&n>=h&&h>=t&&(!d.hasOwnProperty(e.owner.user_id)||d[e.owner.user_id]-h>=p)?(d[e.owner.user_id]=h,h==t&&--t,o.hasOwnProperty(h)||(o[h]=[]),o[h].push({language:u,user:a,link:r,score:e.score+(n-h)/2})):s.push(' <a href="'+r+'">'+a+"</a>")}),e.has_more)runQuery(++a,r);else{for(var i=n,h=[];o.hasOwnProperty(i);){for(var u=$("<tr>").append($("<td>").text(i.toString())),l=$("<td>"),c=$("<td>"),g=$("<td>"),f=0;f<o[i].length;f++){var v=o[i][f];l.append(v.language),c.append($("<a>").html(v.user).attr("href",v.link)),g.append(v.score),f+1<o[i].length&&(l.append("<br><br>"),c.append("<br><br>"),g.append("<br><br>"))}u.append(l).append(c).append(g),h.push(u),--i}$("#answers").find("tbody").append(h),s.length>0?$("#invalid").append(s):$("#invalid").remove()}}var a=1,n=2015,t=n-1,p=5,o={},s=[],d={};e(1,r)})</script><style>html *{font-family: Helvetica, Arial, sans-serif;}table{border: 4px solid #a4a; border-collapse: collapse;}th{background-color: #a4a; color: white; padding: 8px;}td{border: 1px solid #a4a; padding: 8px;}div{font-size: 75%;}</style><table id='answers'> <tr> <th>Year</th> <th>Language</th> <th>User (answer link)</th> <th>Score</th> </tr></table><div id='invalid'><br>Invalid Answers:</div>

2013 - Bản thảo

Dogescript là một ngôn ngữ được tạo ra vào năm 2013 bởi Zach Bruggeman. Không gì khác hơn là một cú pháp thay thế cú pháp cho Javascript để khiến nó đọc giống như những đoạn độc thoại nội tâm của Shiba Inus đáng nhớ.

Xin chào

console dose loge with "Dogescript was made in 2013!"

Nghệ thuật ASCII

such N much N
          much i as 0 next i smaller N next i more 1
              very doge is ("N" + " ".repeat(N-2) + "N").split('')
              s[i] is "N";
              console dose loge with doge.join('')
                              wow
                                      wow

GCD

such gcd_doge much doge, dooge
    rly dooge
              gcd_doge(dooge, doge % dooge)
  but
    rly doge smaller 0
           -doge
    but
          doge
  wow
        wow

2015 - Võng mạc

Retina là một ngôn ngữ lập trình dựa trên regex, mà tôi đã viết để có thể cạnh tranh trong các thử thách PPCG với các câu trả lời chỉ dành cho regex, mà không có chi phí không cần thiết khi gọi regex bằng một số ngôn ngữ máy chủ. Võng mạc là Turing-hoàn chỉnh. Để chứng minh, tôi đã triển khai bộ giải hệ thống 2 thẻ cũng như Quy tắc 110 . Nó được viết bằng C #, do đó nó hỗ trợ cả hương vị .NET (theo mặc định) và hương vị ECMAScript (thông qua một cờ).

Retina có thể hoạt động ở nhiều chế độ, nhưng chế độ phù hợp nhất cho việc tính toán (và chế độ hoàn chỉnh Turing) là chế độ Thay thế. Trong chế độ Thay thế, bạn cung cấp cho Retina số lượng tệp nguồn chẵn. Chúng sau đó được ghép nối, cái đầu tiên của mỗi cặp là regex và cái thứ hai thay thế. Chúng sau đó được thực hiện theo thứ tự, thao tác từng bước đầu vào. Regex cũng có thể được đi trước bởi một cấu hình (được phân định bằng `). Tùy chọn quan trọng nhất (làm cho Retina Turing-Complete) là +, điều này khiến Retina áp dụng thay thế trong một vòng lặp cho đến khi kết quả ngừng thay đổi. Trong các ví dụ sau, tôi cũng đang sử dụng ;, loại bỏ đầu ra ở các giai đoạn trung gian.

Trong mỗi lần gửi sau, mỗi dòng đi trong một tệp nguồn riêng. (Ngoài ra, bạn có thể sử dụng -stùy chọn mới và đặt tất cả các dòng vào một tệp.) Các tệp / dòng trống được thể hiện dưới dạng <empty>. Các tệp / dòng chứa một khoảng trắng được biểu diễn dưới dạng <space>.

Các giải thích khá dài, vì vậy tôi đã chuyển chúng đến cuối bài.

Các chương trình

"Chào thế giới!" Biến thể

<empty>
Retina was made in 2015!

Nghệ thuật ASCII

Điều này giả định rằng STDIN bị chấm dứt với một dòng mới.

;`^
#
;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#
;`#
<empty>
;`\d
N
;`.(?<=(?=(.*\n)).*)|\n
$1
;`N(?=N\n.*\n.*\n`$)
<space>
;+`N(?=.?(.)+\n.* (?<-1>.)+(?(1)!)\n)
<space>
;`(?<=^.*\n.*\nN)N
S
;+`(?<=\n(?(1)!)(?<-1>.)+S.*\n(.)+N?)N
S
S
<space>

GCD

Điều này đòi hỏi STDIN không được chấm dứt với một dòng mới.

;`\b(?=\d)
#
;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#
;`#
<empty>
;`\d
1
;`^(.+)\1* \1+$
$1
;`$
#:0123456789
;+`^(?=1)(1*)\1{9}(#(?=.*(0))|1#(?=.*(?<3>1))|11#(?=.*(?<3>2))|111#(?=.*(?<3>3))|1111#(?=.*(?<3>4))|11111#(?=.*(?<3>5))|111111#(?=.*(?<3>6))|1111111#(?=.*(?<3>7))|11111111#(?=.*(?<3>8))|111111111#(?=.*(?<3>9)))
$1#$3
#|:.*
<empty>

Giải thích

"Chào thế giới!" Biến thể

Điều này là khá tầm thường. Nó không có đầu vào (tức là một chuỗi rỗng), không khớp với gì và thay thế nó bằng Retina was made in 2015!. Người ta cũng có thể làm cho nó hoạt động cho đầu vào tùy ý, bằng cách thay thế mẫu bằng [\s\S]*ví dụ. Điều đó sẽ làm lu mờ STDIN và thay thế tất cả bằng đầu ra.

Nghệ thuật ASCII

Điều này có khá nhiều giai đoạn. Ý tưởng là chuyển đổi đầu vào thành đơn nguyên, tạo một khối N x N của Ns và sau đó "khắc" hai hình tam giác. Chúng ta hãy trải qua các giai đoạn cá nhân. Hãy nhớ rằng ;chỉ đơn thuần là triệt tiêu các đầu ra trung gian, nhưng +làm cho sự thay thế được áp dụng trong một vòng lặp.

;`^
#

Đơn giản: trả trước a #cho đầu vào. Điều này sẽ được sử dụng như một điểm đánh dấu trong việc chuyển đổi thành unary.

;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#

Điều này chuyển đổi một chữ số thành unary. Nó lấy các chữ số đã được chuyển đổi (\d*)và lặp lại chúng 10 lần. Và sau đó nó lấy chữ số tiếp theo và nối thêm số chữ số thích hợp. Giá trị thực của các chữ số là không liên quan ở giai đoạn này. Khi #đến cuối số, regex không còn phù hợp nữa và quá trình chuyển đổi được thực hiện. Ví dụ, số 127sẽ được xử lý như

#127
1#27
111111111122#7
1111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111227777777#

trong đó dòng cuối cùng chứa chính xác 127 ký tự.

;`#
<empty>
;`\d
N

Hai giai đoạn đơn giản loại bỏ điều đó #và sau đó chuyển đổi tất cả các chữ số thành N. Sau đây tôi sẽ sử dụng đầu vào 7làm ví dụ. Vì vậy, bây giờ chúng tôi đã có

NNNNNNN

Giai đoạn tiếp theo

;`.(?<=(?=(.*\n)).*)|\n
$1

thay thế từng Nchuỗi bằng toàn bộ chuỗi (hãy nhớ rằng nó chứa một dòng mới theo dõi) và cũng loại bỏ chính dòng mới đó. Do đó, điều này biến hàng đơn thành một lưới vuông:

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN

Bây giờ là tam giác trên. Đầu tiên, chúng tôi bắt đầu mọi thứ bằng cách biến N ở góc dưới bên phải thành khoảng trắng:

;`N(?=N\n.*\n.*\n`$)
<space>

Cái nhìn đảm bảo rằng chúng tôi sửa đổi chính xác N. Điều này mang lại

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNN N
NNNNNNN
NNNNNNN

Và bây giờ

;+`N(?=.?(.)+\n.* (?<-1>.)+(?(1)!)\n)
<space>

là một regex khớp với một Ncái ở trên hoặc ở góc trên cùng bên trái của một ký tự khoảng trắng và thay thế nó bằng một khoảng trắng. Bởi vì sự thay thế được lặp đi lặp lại, đây thực chất là một trận lũ, biến quãng tám thứ ba từ không gian ban đầu thành nhiều khoảng trống hơn:

N     N
NN    N   
NNN   N
NNNN  N
NNNNN N
NNNNNNN
NNNNNNN

Và cuối cùng, chúng tôi lặp lại điều tương tự với tam giác dưới cùng, nhưng chúng tôi sử dụng một ký tự khác, vì vậy các không gian đã tồn tại không gây ra lũ lụt sai:

;`(?<=^.*\n.*\nN)N
S

đặt hạt giống:

N     N
NN    N   
NSN   N
NNNN  N
NNNNN N
NNNNNNN
NNNNNNN

Sau đó

;+`(?<=\n(?(1)!)(?<-1>.)+S.*\n(.)+N?)N
S

không làm đầy lũ.

N     N
NN    N   
NSN   N
NSSN  N
NSSSN N
NSSSSNN
NSSSSSN

Và cuối cùng

S
<space>

Biến chúng Sthành không gian và chúng ta đã hoàn thành:

N     N
NN    N   
N N   N
N  N  N
N   N N
N    NN
N     N

GCD

GCD trong unary thực sự rất tầm thường với regex. Hầu hết trong số này bao gồm chuyển đổi thập phân sang đơn nhất và đơn nhất sang thập phân. Điều này có thể được thực hiện gọn hơn, nhưng đây không phải là một môn đánh gôn, vì vậy ...

;`\b(?=\d)
#
;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#
;`#
<empty>
;`\d
1

Các giai đoạn này về cơ bản giống như trên, ngoại trừ cả hai số đầu vào được chuyển đổi và kết quả sử dụng 1s thay vì Ns (không quan trọng). Vì vậy, nếu đầu vào là 18 24, thì điều này sẽ tạo ra

111111111111111111 111111111111111111111111

Hiện nay

;`^(.+)\1* \1+$
$1

là toàn bộ tính toán GCD. Chúng tôi khớp với một ước số chung bằng cách bắt một số 1s, và sau đó sử dụng phản hồi để đảm bảo rằng cả hai số có thể được viết bằng cách lặp lại chuỗi đó (và không có gì khác). Do công trình như thế nào backtracking trong động cơ regex (tức mà .+là tham lam), điều này sẽ luôn mang lại lớn nhất ước chung tự động. Vì trận đấu bao trùm toàn bộ chuỗi, chúng tôi chỉ cần viết lại nhóm bắt đầu tiên để lấy GCD của chúng tôi.

Cuối cùng, chuyển đổi đơn nhất sang thập phân ...

;`$
#:0123456789

Nối một điểm đánh dấu #, một dấu phân cách :và tất cả các chữ số vào chuỗi. Điều này là cần thiết, bởi vì bạn không thể tạo ra các ký tự mới một cách có điều kiện trong một sự thay thế regex. Nếu bạn muốn thay thế có điều kiện, bạn cần phải kéo các ký tự từ chính chuỗi, vì vậy chúng tôi đặt chúng ở đó.

;+`^(?=1)(1*)\1{9}(#(?=.*(0))|1#(?=.*(?<3>1))|11#(?=.*(?<3>2))|111#(?=.*(?<3>3))|1111#(?=.*(?<3>4))|11111#(?=.*(?<3>5))|111111#(?=.*(?<3>6))|1111111#(?=.*(?<3>7))|11111111#(?=.*(?<3>8))|111111111#(?=.*(?<3>9)))
$1#$3

Đây là nghịch đảo của việc mở rộng unary trước đó. Chúng tôi tìm thấy bội số lớn nhất của 10 phù hợp với chuỗi hiện tại. Sau đó, chúng tôi chọn chữ số tiếp theo dựa trên phần còn lại và chia bội số cho 10, trong khi di chuyển điểm đánh dấu qua các chữ số.

#|:.*
<empty>

Và cuối cùng chỉ là một bước dọn dẹp để thoát khỏi điểm đánh dấu, dấu phân cách và chữ số của trình trợ giúp.

2013 - Chụp nhanh !

Chộp lấy ! là một ngôn ngữ dựa trên Scratch , được thực hiện tại Đại học Berkeley. Đây là bản nâng cấp lên Scratch có dữ liệu hạng nhất và các khối tùy chỉnh (chức năng). Giống như Scratch, nó không dựa trên văn bản, mà được thực hiện bằng các "khối" trực quan kết hợp với nhau.

Chộp lấy ! , được viết bằng JavaScript, là sự kế thừa của BYOB, được viết bằng Squeak Smalltalk. Chộp lấy ! là phiên bản beta được phát hành cho công chúng vào tháng 3 năm 2013 .

Chộp lấy ! thực sự không phải là một ngôn ngữ bí truyền. Nó được sử dụng làm ngôn ngữ lập trình cho khóa học AP CS Beauty and Joy of Computing (BJC) tại Berkeley và những người khác.

Tôi đã giúp kiểm tra và các công cụ.

Biến thể "Xin chào thế giới"

Nghệ thuật ASCII "N"

Điều này sử dụng stdlib cho một số khối.

Khá lặp cơ bản ở đây. Có một đầu vào. Sau đó, chúng tôi chỉ cần cộng tất cả lại với nhau và nói (kết quả cho n = 5):

Tôi lấy tự do ở đây để chỉ sử dụng 2 khoảng trắng thay vì 1, vì Snap! không nói những thứ trong không gian vũ trụ.

GCD

Thuật toán Euclide không nhanh lắm, nhưng nó hoạt động và khá đơn giản. (Xin lỗi, tôi đã mắc lỗi đánh máy trong tên khối. Bây giờ tôi đã đóng tab mà không lưu. Nó sẽ phải ở lại.)

Định nghĩa hàm này sau đó sẽ tạo ra khối này:

2007 - LOLCODE

Lịch sử ngôn ngữ

LOLCODE được tạo ra vào năm 2007 bởi Adam Lindsay, một nhà nghiên cứu tại Đại học Lancaster. Cú pháp của nó dựa trên các meme lolcats phổ biến bởi Cheezburger, Inc.

"Chào thế giới!" Biến thể

HAI
VISIBLE "LOLCODE wuz maed in 2007!"
KTHXBYE

Nghệ thuật ASCII

HAI

BTW, read n from stdin
GIMMEH n

BTW, convert n from YARN to NUMBR
n R PRODUKT OF n AN 1

BOTH SAEM n AN 1, O RLY?
    YA RLY
        VISIBLE "N"
    NO WAI
        VISIBLE "N"!

        I HAS A butt ITZ 1
        IM IN YR toilet UPPIN YR butt TIL BOTH SAEM butt AN DIFF OF n AN 1
            VISIBLE " "!
        IM OUTTA YR toilet

        VISIBLE "N"

        I HAS A kat ITZ 2
        IM IN YR closet UPPIN YR kat TIL BOTH SAEM kat AN n
            VISIBLE "N"!
            BOTH SAEM kat AN 2, O RLY?
                YA RLY
                    VISIBLE "N"!
                NO WAI
                    I HAS A doge ITZ 1
                    IM IN YR l00p UPPIN YR doge TIL BOTH SAEM doge AN DIFF OF kat AN 1
                        VISIBLE " "!
                    IM OUTTA YR l00p
                    VISIBLE "N"!
            OIC

            I HAS A brd ITZ 1
            IM IN YR haus UPPIN YR brd TIL BOTH SAEM brd AN DIFF OF n AN kat
                VISIBLE " "!
            IM OUTTA YR haus

            VISIBLE "N"
        IM OUTTA YR closet

        VISIBLE "N"!

        I HAS A d00d ITZ 1
        IM IN YR lap UPPIN YR d00d TIL BOTH SAEM d00d AN DIFF OF n AN 1
            VISIBLE " "!
        IM OUTTA YR lap

        VISIBLE "N"
OIC

KTHXBYE

Các giá trị được đọc dưới dạng chuỗi (YARN) từ stdin bằng cách sử dụng GIMMEH. Chúng có thể được chuyển đổi thành số (NUMBR) bằng cách nhân với 1.

Các giá trị được in ra thiết bị xuất chuẩn bằng cách sử dụng VISIBLE. Theo mặc định, một dòng mới được nối thêm, nhưng nó có thể bị chặn bằng cách thêm một dấu chấm than.

GCD

HAI

GIMMEH a
a R PRODUKT OF a AN 1

GIMMEH b
b R PRODUKT OF b AN 1

I HAS A d00d ITZ 1
IM IN YR food UPPIN YR d00d TIL BOTH SAEM b AN 0
    I HAS A kitty ITZ a
    I HAS A doge ITZ b
    a R doge
    b R MOD OF kitty AN doge
IM OUTTA YR food

VISIBLE SMOOSH "gcd is " a

KTHXBYE

SMOOSH thực hiện nối chuỗi.

1982 - PostScript

PostScript là một ngôn ngữ để tạo đồ họa vector và in ấn.

Adobe được thành lập vào năm 1982 và sản phẩm đầu tiên của họ là PostScript. Ngôn ngữ được sử dụng trong máy in: các lệnh được máy in diễn giải để tạo ra hình ảnh raster, sau đó được in lên trang. Nó là một thành phần rất phổ biến của máy in laser vào những năm 1990. Nhưng rõ ràng là CPU sử dụng khá nhiều máy in và khi bộ xử lý máy tính trở nên mạnh hơn, việc thực hiện rasterisation trên máy tính sẽ có ý nghĩa hơn so với máy in. PostScript phần lớn đã biến mất trên các máy in tiêu dùng, mặc dù nó vẫn tồn tại trên rất nhiều máy in cao cấp hơn.

Tiêu chuẩn thay thế PostScript là một định dạng ít được gọi là PDF.

PostScript đã bị lỗi mốt khi tôi bắt đầu lập trình, nhưng tôi đã học được một chút khi còn ở trường đại học như một cách khác để tạo tài liệu cho TeX. Nó khá khác với các ngôn ngữ lập trình khác mà tôi đã sử dụng (ký hiệu ngược, xếp chồng, in ra một trang thay vì bảng điều khiển), nhưng thật tuyệt khi loại bỏ ngôn ngữ cũ này để giải trí.

Vì PostScript là một ngôn ngữ in, nên có vẻ phù hợp hơn để sử dụng nó để in một cái gì đó sau đó gửi một đầu ra đến bàn điều khiển.

Nhiệm vụ 1

/Courier findfont
12 scalefont
setfont
newpath

100 370 moveto
(PostScript was made in 1982!\n) show

Một vài dòng đầu tiên thiết lập một bức tranh để vẽ. Sau đó, movetolệnh yêu cầu PS vẽ tại một vị trí cụ thể và showin chuỗi lên trang. Lưu ý rằng dấu ngoặc đơn đánh dấu một chuỗi trong PostScript, không phải dấu ngoặc kép.

Nhiệm vụ 2

/asciiartN {% stack: N row col
            % output: draws an "ASCII art" N

  % PostScript doesn't allow you to pass variables directly into a function;
  % instead, you have to pass variables via the global stack. Pop the variables
  % off the stack and define them locally.
  6 dict begin
  /row exch def
  /col exch def
  /N exch def

  % Define how much space will be between each individual "N"
  /spacing 15 def

  % Get the width of the "N". We need this to know where to draw the right-hand
  % vertical
  /endcol col spacing N 1 sub mul add def

  % One row is drawn at a time, with the bottom row drawn first, and working
  % upwards. This stack variable tracks which column the diagonal is in, and so
  % we start on the right and work leftward
  /diagcol endcol def

  % Repeat N times: draw one row at a time
  N {
    % Left-hand vertical of the "N"
    col row moveto
    (N) show

    % Right-hand vertical of the "N"
    endcol row moveto
    (N) show

    % Diagonal bar of the "N"
    diagcol row moveto
    (N) show

    % Advance to the next row. This means moving the row one space up, and the
    % diagonal position one place to the left.
    /row row spacing add def
    /diagcol diagcol spacing sub def

  } repeat

  end
} def

1 100 200 asciiartN
3 150 200 asciiartN
5 230 200 asciiartN

Tôi đã viết một hàm để vẽ nghệ thuật ASC NII của N, nhưng không có cách nào để các hàm PostScript có thể tranh luận. Thay vào đó, bạn đẩy các đối số của mình lên ngăn xếp, sau đó lấy lại chúng. Đó là /x exch defdòng.

Một ví dụ: giả sử ngăn xếp là 8 9 2. Đầu tiên chúng ta đẩy tên /xvào ngăn xếp, vì vậy ngăn xếp là 8 9 2 /x. Các exchnhà điều hành giao dịch hoán đổi hai giá trị ngăn xếp, vì vậy bây giờ chồng là 8 9 /x 2. Sau đó defbật hai giá trị ngăn xếp trên cùng và xác định /xđể có giá trị 2. Bây giờ là ngăn xếp 8 9.

Khi tôi bắt đầu sử dụng PostScript, tôi thấy điều này hơi khó hiểu. Tôi đã đọc về stack như một khái niệm lý thuyết, nhưng đây là lần đầu tiên tôi sử dụng nó trong thực tế.

Phần còn lại của hàm là một số mã vẽ: bắt đầu ở góc dưới bên phải, điền vào một hàng tại một thời điểm từ trái sang phải sang chéo.

Nhiệm vụ 3

/modulo {% stack: x y
         % output: returns (x mod y)
  3 dict begin
  /y exch def
  /x exch def

  % If x = y then (x mod y) == 0
  x y eq {0} {

    % If x < y then (x mod y) == x
    x y lt {x} {

      % If x > y then subtract floor(x/y) * y from x
      /ycount x y div truncate def
      /x x ycount y mul sub def

      /x x cvi def
      x

    } ifelse
  } ifelse
} def

/gcd {% stack: a b
      % returns the gcd of a and b
  2 dict begin
  /b exch def
  /a exch def

  % I'm using the recursive version of the Euclidean algorithm

  % If b = 0 then return a
  b 0 eq {a} {

    % Otherwise return gcd(b, a mod b)
    /a a b modulo def
    b a gcd
  } ifelse

} def

/displaygcd {% stack: a b xcoord ycoord
             % displays gcd(a,b) at position (xcoord, ycoord)
  5 dict begin
  /ycoord exch def
  /xcoord exch def
  /b exch def
  /a exch def
  /result a b gcd def

  xcoord ycoord moveto
  result 20 string cvs show

  % end
} def

8 12 100 80 displaygcd
12 8 150 80 displaygcd
3 30 200 80 displaygcd
5689 2 250 80 displaygcd
234 876 300 80 displaygcd

Một lần nữa, tôi đã sử dụng một dạng thuật toán của Euclid, nhưng tôi đã quên rằng PostScript có một toán tử modulo tích hợp, vì vậy tôi phải tự viết. Điều này hóa ra là một lời nhắc nhở hữu ích về các ràng buộc của lập trình dựa trên ngăn xếp. Việc thực hiện đầu tiên của tôi modulodựa trên đệ quy:

modulo(x, y)
    if (x = y) return 0
    elif (x < y) return x
    else return module(x - y, y)

sẽ ổn cho đến khi bạn cố chạy cái này khi xlớn và ynhỏ (ví dụ 5689 và 2). Bạn chỉ có thể có tối đa 250 phần tử trên ngăn xếp, và vì vậy tôi đã vượt quá giới hạn ngăn xếp. Úi. Tôi phải quay lại bảng vẽ trên đó.

Bản thân mã GCD khá đơn giản. Nhưng cũng giống như các hàm không thể lấy tham số, vì vậy chúng không có giá trị trả về. Thay vào đó, bạn phải đẩy kết quả đến ngăn xếp nơi người khác có thể bật nó sau. Đó là những gì avà b a gcddòng làm: khi họ đánh giá xong, họ đẩy giá trị lên ngăn xếp.

Nếu bạn đặt tất cả mã vào một tài liệu và in nó, đây là kết quả đầu ra:

2009 - > <>

Lấy cảm hứng từ Befunge,> <> (Cá) là ngôn ngữ 2D dựa trên ngăn xếp bí truyền, tức là dòng chương trình có thể lên, xuống, trái hoặc phải. Phiên bản ban đầu của> <> đa luồng đặc trưng ở đâu [và các luồng ]được tạo và kết thúc, nhưng vì lý do đơn giản, các hướng dẫn này đã được thay đổi để tạo và loại bỏ các ngăn xếp mới tương ứng.

Trình thông dịch chính thức hiện tại cho> <> có thể được tìm thấy ở đây . Thật không may, liên kết đến trình thông dịch cũ trên wiki Esolang bị hỏng.

"Chào thế giới!" Biến thể

"!9002 ni edam saw ><>"l?!;obb+0.

Lưu ý cách chuỗi được viết ngược -> <> về mặt kỹ thuật không có chuỗi, với kiểu dữ liệu duy nhất là sự pha trộn kỳ lạ của char, int và float. "bật tắt phân tích chuỗi, đẩy từng ký tự lên ngăn xếp cho đến khi kết thúc đóng ".

Nửa sau của mã sau đó đẩy chiều dài của ngăn xếp l, kiểm tra xem nó có bằng không không ?!và nếu có thì chương trình sẽ kết thúc ;. Mặt khác, con trỏ lệnh tiếp tục, xuất ra đỉnh của ngăn xếp otrước khi thực hiện bb+0., dịch chuyển tức thời con trỏ đến vị trí (22, 0)ngay trước l, tạo ra một vòng lặp.

Nghệ thuật ASCII

&0 > :&:&:*=?;  :&:&%  :0=?v  :&:&1-=?v  :{:{-&:&,{=?v   " " o   \

                           > ~"N"o                           v    
   +                                  > ~"N"oao              v    
   1                                                 >"N"o   v    

   \                                                         <   /

Với khoảng cách cho rõ ràng. Bạn có thể thử điều này tại trình thông dịch trực tuyến mới tại đây và xem con trỏ lệnh đi xung quanh - chỉ cần nhớ nhập một số trong hộp văn bản "Ngăn xếp ban đầu". Nếu bạn đang chạy qua trình thông dịch Python, hãy sử dụng -vcờ để khởi tạo ngăn xếp, ví dụ:

py -3 fish.py ascii.fish -v 5

Đối với chương trình này, chúng tôi đưa đầu nvào vào thanh ghi bằng &và ấn 0, chúng tôi sẽ gọi là i"lặp". Phần còn lại của chương trình là một vòng lặp khổng lồ diễn ra như sau:

:&:&:*=?;          If i == n*n, halt. Otherwise ...
:&:&%              Push i%n
:0=?v              If i%n == 0 ...
>~"N"o               Print "N"
:&:&1-=?v          Else if i%n == n-1 ...
>~"N"oao             Print "N" and a newline
:{:{-&:&,{=?v      Else if i%n == i//n, where // is integer division...
>~"N"o               Print "N"
" "o               Otherwise, print a space
1+                 Increment i

Sau đó, chúng tôi lặp lại vòng lặp từ đầu.

Các mũi tên ^>v<thay đổi hướng của luồng chương trình và các gương /\phản ánh hướng của luồng chương trình.

GCD

>:{:}%\
;n{v?:/
v~@/

Đây là một ví dụ về những gì một chương trình golf> <> có thể trông như thế nào. Một lần nữa, bạn có thể thử điều này trong trình thông dịch trực tuyến (nhập hai giá trị được phân tách bằng dấu phẩy vào hộp "Ngăn xếp ban đầu", ví dụ 111, 87) hoặc bằng cách sử dụng -vcờ của trình thông dịch Python, ví dụ:

py -3 fish.py gcd.fish -v 111 87

Chương trình này sử dụng thuật toán Euclide. Đây là một GIF tôi đã chuẩn bị trước đó:

Lưu ý rằng> <> là hình xuyến, vì vậy khi lệnh bên trái phía dưới vđược thực thi, con trỏ lệnh sẽ đi xuống, quấn quanh và xuất hiện lại ở trên cùng.

Chỉnh sửa: Bằng cách làm cho mã chạy hoàn toàn từ phải sang trái , @randomra quản lý để cạo ba byte bằng

<~@v!?:%}:{:
;n{/

Đoán tôi đã không chơi golf đủ rồi :)

2012 - Yếu tố

Đây là một ngôn ngữ mà tôi đã phát minh ra vào đầu năm 2012 để trở thành một ngôn ngữ chơi golf đơn giản. Bằng cách này, tôi có nghĩa là có rất ít hoặc không có quá tải toán tử. Các nhà khai thác cũng đơn giản hơn và số lượng ít hơn so với hầu hết các ngôn ngữ golf hiện đại.

Các tính năng thú vị nhất của ngôn ngữ này là cấu trúc dữ liệu của nó. Có hai ngăn xếp và hàm băm được sử dụng để lưu trữ thông tin.

M-stack là ngăn xếp chính, nơi diễn ra số học và hầu hết các hoạt động khác. Khi dữ liệu được nhập hoặc in, đây là nơi nó đi hoặc được lấy từ đó.

Ngăn xếp c là ngăn xếp điều khiển. Đây là nơi diễn ra số học boolean. Các giá trị trên cùng của ngăn xếp c được sử dụng bởi các vòng lặp If và While làm điều kiện.

Băm là nơi các biến được lưu trữ. Các ;và ~lưu trữ và lấy dữ liệu từ băm, tương ứng.

Yếu tố là một ngôn ngữ đánh máy rất yếu. Nó sử dụng khả năng của Perl để tự do diễn giải các số dưới dạng chuỗi và ngược lại.

Trong khi tôi đang ở đó, tôi cũng có thể bao gồm tất cả các tài liệu cho ngôn ngữ. Bạn có thể tìm thấy trình thông dịch gốc năm 2012, được viết bằng Perl, ngay tại đây . Cập nhật: Tôi đã tạo một phiên bản có thể sử dụng nhiều hơn, mà bạn có thể tìm thấy ngay tại đây .

OP    the operator.  Each operator is a single character
STACK tells what stacks are affected and how many are popped or pushed
      "o" stands for "other effect"
HASH  tells if it involves the hash
x & y represent two values that are already on the stack, so the effect of
      the operator can be more easily described

OP     STACK  HASH   DESCRIPTION
text     ->m         --whenever a bare word appears, it pushes that string onto 
                       the main stack
_       o->m         --inputs a word and pushes onto main stack
`       m->o         --output.  pops from main stack and prints
xy;    mm->    yes   --variable assignment.  the top stack element y is assigned 
                       the value x
~       m->m   yes   --variable retrieval.  pops from main stack, pushes contents 
                       of the element with that name
x?      m->c         --test. pops x and pushes 0 onto control stack if x is '0' or 
                       an empty string, else pushes 1
><=     m->c         --comparison. pops two numbers off of stack and performs 
                       test, pushes 1 onto control stack if true and 0 if false
'       m->c         --pops from main stack and pushes onto control stack
"       c->m         --pops from control stack and pushes onto main stack
&|     cc->c         --AND/OR. pops two items from control stack, performs and/or 
                       respectively, and pushes result back onto control stack
!       c->c         --NOT. pops a number off of control stack, pushes 1 if 0 or 
                       empty string, 0 otherwise
[]       c           --FOR statement (view the top number number from control stack 
                       and eval those many times)
{}       c           --WHILE (loop until top number on control stack is 0, also 
                       does not pop)
#       m->          --discard. pops from main stack and destroys
(       m->mm        --pops from main stack, removes first character, pushes the 
                       remaining string onto stack, and pushes the removed character 
                       onto stack
)       m->mm        --pops from main stack, removes last character, pushes the 
                       remaining string onto stack, and pushes the removed character 
                       onto stack
+-*/%^ mm->m         --arithmetic. pops two most recent items, adds/negates
                       /multiplies/divides/modulates/exponentiates them, and places 
                       the result on the stack 
xy@    mm->o         --move. pops x and y and moves xth thing in stack to move to 
                       place y in stack
x$      m->m         --length. pops x and pushs length of x onto the stack
xy:    mm->o         --duplication. pops x and y and pushes x onto the stack y times
xy.    mm->m         --concatination. pops x and y and pushes x concatonated with y
\        o           --escapes out of next character, so it isn't an operator and can
                       be pushed onto the stack
,      m->mm         --character conversion. pops from main stack, coverts it to char
                       and pushes, and converts to num and pushes
Newlines and spaces separate different elements to be pushed 
onto the stack individually, but can pushed onto the stack using \

Nhiệm vụ 1 - In văn bản

Element\ was\ made\ in\ 2012\!`

Một trong những phần khó xử hơn của ngôn ngữ là thiếu các dấu phân cách chuỗi, đó là lý do tại sao các ký tự thoát là cần thiết trong chuỗi này. Các `cuối cùng in chuỗi.

Nhiệm vụ 2 - ASCII Art N

_+'[y~1+y;0[1+4:"2:'=1=|y~=|\ [#N]`"#]\
`]

Ở đây, bạn sẽ chứng kiến ​​một số thao tác ngăn xếp. Để giải thích dễ dàng hơn một chút về định dạng, tôi sẽ thay thế dòng mới bằng một Lvà khoảng trắng bằng một S.

_+'[y~1+y;0[1+4:"2:'=1=|y~=|\S[#N]`"#]\L`]
_+'      input line, convert to #, move to c-stack
[        FOR loop
 y~1+y;  increment the y-pos
 0       set the x-pos (the top # on the stack) to zero
 [       FOR loop
  1+4:   increment x-pos and make 3 additional copies (4 is total #)
  "2:'   make a copy of the N size on the main stack
  =      if x-pos == size
  1=     or if x-pos == 1
  y~=|   of if x-pos == y-pos
  \S     (always) push a space
  [      the IF body (technically a FOR loop)
   #N    if true, remove the space and push an N
  ]      end IF
  `      output the pushed character
  "#     remove the result of the conditional
 ]       end x-pos FOR
 \L`     output a newline
]        end y-pos FOR

Sau khi thực hiện một số thao tác cực đoan của câu trả lời này, tôi đã tìm thấy một giải pháp 39 byte, mặc dù nó phức tạp hơn nhiều.

_'1[y~+y;[#1+3:"2:'%2<y~=|\ [#N]`"]\
`]

Nhiệm vụ 3 - GCD

__'{"3:~2@%'}`

Đây là một phương pháp dựa trên ngăn xếp.

__                 input the two numbers
  '                use one of the number as a condition so the WHILE loop starts
   {        }      a WHILE loop. Repeats while the c-stack has a true value on top
    "              get the number back from the c-stack to do operations on it
     3:            make it so that there are threes copies on the stack
       ~           takes one of the copies from earlier and converts it to a zero
        2@         take the top item on the stack and move it behind the other two #s
          %        modulo operation
           '       use this number as the condition
             `     since one number is zero (and on the c-stack) print the 
                   other number, which is on m-stack

2012 - Julia

Lịch sử ngôn ngữ

Julia được phát triển vào năm 2012 bởi Jeff Bezanson, Stefan Karpinki và Viral Shah trong khi Jeff là sinh viên của Học viện Công nghệ Massachussets (MIT), được cố vấn bởi giáo sư Alan Edelman. Họ được thúc đẩy bởi mong muốn về một ngôn ngữ lập trình là nguồn mở, nhanh và năng động (trong số nhiều thứ khác) trong khi vẫn duy trì sự dễ sử dụng trong nhiều ứng dụng. Sản phẩm là Julia, một cách tiếp cận mới mẻ đối với máy tính khoa học hiệu năng cao.

"Chào thế giới!" Biến thể

println("Julia was made in 2012!")

In sang STDOUT trong Julia khá đơn giản!

Nghệ thuật ASCII

function asciin(n)
    # Create an nxn matrix of spaces
    m = fill(" ", (n, n))

    # Fill the first and last columns with "N"
    m[:,1] = m[:,n] = "N"

    # Fill the diagonal elements with "N"
    setindex!(m, "N", diagind(m))

    # Print each row of the matrix as a joined string
    for i = 1:n
        println(join(m[i,:]))
    end
end

Mã được thụt lề để dễ đọc, nhưng Julia không đặt ra giới hạn nào cho khoảng trắng.

GCD

function g(a, b)
    b == 0 ? a : g(b, a % b)
end

Điều cuối cùng được liệt kê trong hàm được trả lại ngầm.

1988 - Toán học

Hay tôi nên gọi nó là Ngôn ngữ Wolfram ?

Nhiệm vụ 0

Người tạo ra Mathicala là Stephen Wolfram, Người sáng lập và Giám đốc điều hành của Wolfram Research. Trước sự phát triển của Mathematica, ông là một nhà vật lý. Có một số lượng lớn tính toán đại số trong vật lý, vì vậy ông trở thành người sử dụng Macsyma .

Wolfram có PHD vào năm 1979, khi anh ta 20. Anh ta nghĩ rằng anh ta cần một CAS tốt hơn Macsyma để làm vật lý, vì vậy anh ta bắt đầu viết SMP ("Chương trình thao tác tượng trưng"). Phiên bản đầu tiên của SMP được phát hành vào năm 1981. SMP là tiền thân của Mathematica. Mặc dù nó có ảnh hưởng sâu sắc đến Mathematica, nhưng không có mã nào được sử dụng cho Mathicala.

Năm 1986, Wolfram quyết định viết một "hệ thống tính toán cuối cùng". Ông bắt đầu viết mã vào năm 1986 và thành lập Nghiên cứu Wolfram vào năm 1987. Cuối cùng, Mathematica 1.0 được phát hành vào ngày 23 tháng 6 năm 1988.

Tôi đã không tìm thấy Mathicala 1.0. Trên thực tế, Mathicala 1.0 không có phiên bản Windows hay Linux. Nhưng tôi đã tìm thấy Mathematica 2.0 trên một trang web của Trung Quốc. Nó vẫn có thể chạy trên Windows XP.

Nhiệm vụ 1

Print["Mathematica was made in 1988!"]

Hoặc đơn giản:

"Mathematica was made in 1988!"

Nhiệm vụ 2

Trong Mathicala ngày nay, chúng ta có thể viết:

asciiArtN[n_] := Print @@@ SparseArray[{i_, 1 | i_ | n} -> "N", {n, n}, " "]

Giống như Julia và R , đây là một giải pháp ma trận. Trong Mathicala, bạn có thể xác định ma trận thưa thớt bằng cách sử dụng khớp mẫu.

Tuy nhiên, SparseArrayđã được giới thiệu trong Mathicala 5.0, vì vậy chúng tôi không thể sử dụng nó trong Mathicala 1.0.

Đây là một giải pháp hoạt động trong Mathicala 1.0:

asciiArtN[n_] := Block[{f},
  f[i_, 1]  = "N";
  f[i_, i_] = "N";
  f[i_, n]  = "N";
  f[__]     = " ";
  Apply[Print, Array[f, {n, n}], 1];
]

Chúng tôi không thể viết f[i_, 1 | i_ | n] = "N"vì Alternativesđã được giới thiệu trong Mathematica 2.0.

Nhiệm vụ 3

Chúng ta chỉ có thể sử dụng chức năng tích hợp:

gcd = GCD

Hoặc chúng ta có thể sử dụng định nghĩa của GCD:

gcd = Max[Intersection @@ Divisors[{##}]] &;

Hoặc chúng ta có thể sử dụng LCM , mặc dù LCM được tính toán phổ biến hơn từ GCD:

gcd = Times[##]/LCM[##] &;

Hoặc chúng ta có thể sử dụng thuật toán Euclide với khớp mẫu:

gcd[a_, 0] := a
gcd[a_, b_] := gcd[b, Mod[a, b]]

Hoặc là một chức năng ẩn danh:

gcd = If[#2 == 0, #1, #0[#2, Mod[##]]] &;

Tất cả các chức năng trên đã được giới thiệu trong Mathicala 1.0.

1999 - XSLT

Các World Wide Web Consortium (W3C) tạo XSLT để chuyển đổi XML sang HTML, văn bản, vv Các ví dụ sau đây giả định đầu vào được kèm theo trong <input>..</input>thẻ.

Nhiệm vụ 1

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text" indent="no"/>
  <xsl:template match="/input">XSLT was made in 1999!</xsl:template>
</xsl:stylesheet>

Điều này là đơn giản. Nó phù hợp với một inputthẻ ở cấp cao nhất và thay thế nó với đầu ra mong muốn.

Nhiệm vụ 2

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text" indent="no"/>
  <xsl:template match="/input">
    <xsl:call-template name="loop">
      <xsl:with-param name="i">1</xsl:with-param>
      <xsl:with-param name="n">
        <xsl:value-of select="."/>
      </xsl:with-param>
    </xsl:call-template>
  </xsl:template>
  <xsl:template name="loop">
    <xsl:param name="i"/>
    <xsl:param name="n"/>
    <xsl:choose>
      <xsl:when test="$i = 1 or $i = $n">
        <xsl:text>N</xsl:text>
        <xsl:call-template name="spaces">
          <xsl:with-param name="n">
            <xsl:value-of select="$n - 2"/>
          </xsl:with-param>
        </xsl:call-template>
        <xsl:text>N&#13;&#10;</xsl:text>
      </xsl:when>
      <xsl:otherwise>
        <xsl:text>N</xsl:text>
        <xsl:call-template name="spaces">
          <xsl:with-param name="n">
            <xsl:value-of select="$i - 2"/>
          </xsl:with-param>
        </xsl:call-template>
        <xsl:text>N</xsl:text>
        <xsl:call-template name="spaces">
          <xsl:with-param name="n">
            <xsl:value-of select="$n - $i - 1"/>
          </xsl:with-param>
        </xsl:call-template>
        <xsl:text>N&#13;&#10;</xsl:text>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:if test="$i &lt; $n">
      <xsl:call-template name="loop">
        <xsl:with-param name="i">
          <xsl:value-of select="$i + 1"/>
        </xsl:with-param>
        <xsl:with-param name="n">
          <xsl:value-of select="$n"/>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:if>
  </xsl:template>
      <xsl:template name="spaces">
    <xsl:param name="n"/>
    <xsl:if test="$n &gt; 0">
      <xsl:text> </xsl:text>
      <xsl:call-template name="spaces">
        <xsl:with-param name="n">
          <xsl:value-of select="$n - 1"/>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:if>
  </xsl:template>
</xsl:stylesheet>

Cái này định nghĩa 2 mẫu đệ quy loopvà spaces. loopvới các tham số ivà nsẽ tạo đầu ra mong muốn cho n, bắt đầu từ vị trí i. spacesvới tham số nsẽ tạo nkhoảng trắng.

Nhiệm vụ 3

Đầu vào cho điều này phải được trong <input><num>..</num><num>..</num></input>các thẻ.

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text" indent="no"/>
  <xsl:template match="/input">
    <xsl:call-template name="gcd">
      <xsl:with-param name="a"><xsl:value-of select="num[1]"/></xsl:with-param>
      <xsl:with-param name="b"><xsl:value-of select="num[2]"/></xsl:with-param>
    </xsl:call-template>
  </xsl:template>
  <xsl:template name="gcd">
    <xsl:param name="a"/>
    <xsl:param name="b"/>
    <xsl:choose>
      <xsl:when test="$b = 0"><xsl:value-of select="$a"/></xsl:when>
      <xsl:otherwise>
        <xsl:call-template name="gcd">
          <xsl:with-param name="a"><xsl:value-of select="$b"/></xsl:with-param>
          <xsl:with-param name="b"><xsl:value-of select="$a mod $b"/></xsl:with-param>
        </xsl:call-template>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>
</xsl:stylesheet>

Đây chỉ là một mẫu đệ quy gcdsử dụng thuật toán Euclide.

2014 -

CJam được tạo bởi người dùng aditsu PPCG và được phát hành vào khoảng tháng 4 năm 2014 .

"Chào thế giới!" Biến thể

"CJam was made in 2014!"

CJam tự động in nội dung của ngăn xếp vào cuối chương trình

Nghệ thuật ASCII

ri:R'#*a_R2-,{_)S*'#+\R((-zS*+}%+\+R<zN*

Mã giải thích:

ri:R                                       "Read the input as integer in R";
    '#*a                                   "Get a string of R # and wrap it in an array";
        _R2-,{                }%           "Copy that string and then run this loop R-2";
                                           "times for the diagonal";
              _)S*                         "Get iteration index + 1 spaces";
                  '#+                      "Append the hash";
                     \R((-zS*+             "Append remaining spaces";
                                +\+        "Append and prepend the initial # string";
                                   R<      "Take only R columns/rows. This is for";
                                           "tackling input 1";
                                     zN*   "Transpose and join with new lines";

Lấy chiều cao / chiều rộng của N làm đầu vào thông qua STDIN. Dùng thử trực tuyến tại đây

GCD

l~{_@\%}h;

Lấy hai số làm đầu vào thông qua STDIN. Dùng thử trực tuyến tại đây

1990 - Haskell

Haskell là một ngôn ngữ chức năng thuần túy phổ biến (hoặc tôi nên nói: phổ biến nhất ?). Nó vượt ra khỏi dòng chính bởi mô hình đánh giá bất thường của nó (theo mặc định, mọi thứ đều lười biếng hoặc, về mặt kỹ thuật, không nghiêm ngặt) và bởi hệ thống loại dựa trên Hindley-Milner, mà ngay cả bây giờ, vẫn là một trong những thế lực mạnh nhất hiện có.

Nhiệm vụ 1

main = putStrLn "Haskell was made in 1990!"

Nhiệm vụ 2

-- Infinite list of growing letters 'N'
bigNs :: [[[Char]]]
bigNs = ["N"]
      : ["NN","NN"]
      : [ ins (ins 'N' t) $ map (ins ' ') n | n@(t:_) <- tail bigNs ]

-- Insert a new element after the head (i.e. at the second position).
ins :: a -> [a] -> [a]
ins x (l:ls) = l:x:ls

Bản trình diễn, in toàn bộ danh sách vô hạn (cho đến khi người dùng hủy bỏ hoặc thế giới kết thúc ...)

GHCi> mapM_ (putStrLn . unlines) bigNs
N

NN
NN

N N
NNN
N N

N  N
NN N
N NN
N  N

N   N
NN  N
N N N
N  NN
N   N

N    N
NN   N
N N  N
N  N N
N   NN
N    N

...

Tất nhiên, bạn có thể dễ dàng truy cập vào một trong số này, bằng cách chỉ truy cập một yếu tố của danh sách vô hạn:

main :: IO ()
main = do
   i <- readLn
   putStrLn . unlines $ bigNs!!i

Nhiệm vụ 3

gcd' :: Integer -> Integer -> Integer
gcd' a 0 = a
gcd' a b = gcd' b $ a`mod`b

Năm 1972 - INTERCAL

Và bạn nghĩ Fortran và Cobol thật kỳ lạ. Điều này thật điên rồ!

Nhiệm vụ 1

DO ,1 <- #27
DO ,1SUB#1 <- #110
DO ,1SUB#2 <- #32
DO ,1SUB#3 <- #72
PLEASE DO ,1SUB#4 <- #136
DO ,1SUB#5 <- #88
DO ,1SUB#6 <- #136
PLEASE DO ,1SUB#7 <- #64
DO ,1SUB#8 <- #80
DO ,1SUB#9 <- #46
PLEASE DO ,1SUB#10 <- #22
DO ,1SUB#11 <- #104
DO ,1SUB#12 <- #184
PLEASE DO ,1SUB#13 <- #202
DO ,1SUB#14 <- #78
DO ,1SUB#15 <- #48
PLEASE DO ,1SUB#16 <- #96
DO ,1SUB#17 <- #128
DO ,1SUB#18 <- #162
PLEASE DO ,1SUB#19 <- #110
DO ,1SUB#20 <- #32
DO ,1SUB#21 <- #114
PLEASE DO ,1SUB#22 <- #120
DO ,1SUB#23 <- #240
DO ,1SUB#24 <- #128
PLEASE DO ,1SUB#25 <- #208
DO ,1SUB#26 <- #200
DO ,1SUB#27 <- #52
DO READ OUT ,1
DO GIVE UP

Tôi sẽ không cố gắng giải thích hệ thống đầu vào và đầu ra của INTERCAL; Chỉ cần đọc nó và hy vọng bạn không chết.

Nhiệm vụ 2

DO WRITE IN 7
DO .1 <- .7
DO .2 <- #1
PLEASE DO (1010) NEXT
DO .8 <- .3
DO .5 <- .7
DO .6 <- .8
DO ,9 <- #2

DO (100) NEXT
DO (1) NEXT

(100) DO (99) NEXT
DO ,9SUB#1 <- #142
DO ,9SUB#2 <- #114
PLEASE DO READ OUT ,9
DO ,9SUB#1 <- #176
DO ,9SUB#2 <- #80
PLEASE DO READ OUT ,9
PLEASE GIVE UP

(99) DO .1 <- .7
DO .2 <- #1
PLEASE DO (1010) NEXT
DO .1 <- '.3~.3'~#1
PLEASE DO FORGET .1
DO RESUME #1

(1) PLEASE DO (3) NEXT
PLEASE DO FORGET #1
DO (1) NEXT

(3) DO (4) NEXT
PLEASE GIVE UP

(4) DO (8) NEXT
DO ,9SUB#1 <- #176
DO ,9SUB#2 <- #80
PLEASE DO READ OUT ,9
DO .6 <- .8
DO .1 <- .5
DO .2 <- #1
DO (1010) NEXT
DO .5 <- .3
DO .1 <- '.5~.5'~#1
PLEASE DO FORGET .1
DO RESUME #1

(8) DO (5) NEXT

(5) PLEASE DO (6) NEXT
PLEASE DO FORGET #1
DO (5) NEXT

(6) PLEASE DO (7) NEXT
DO RESUME #2

(7) DO (10) NEXT
DO .1 <- .6
DO .2 <- #1
PLEASE DO (1010) NEXT
DO .6 <- .3
DO .1 <- '.6~.6'~#1
PLEASE DO FORGET .1
DO RESUME #1

(10) DO (11) NEXT
DO (13) NEXT
DO (14) NEXT
DO (15) NEXT

(11) DO (111) NEXT
DO (112) NEXT

(13) DO (113) NEXT
DO (112) NEXT

(14) DO (114) NEXT
DO (112) NEXT

(111) DO .1 <- .6
DO .2 <- .8
DO (1010) NEXT
DO .1 <- '.3~.3'~#1
PLEASE DO FORGET .1
DO RESUME #1

(112) DO ,9SUB#1 <- #142
DO ,9SUB#2 <- #114
PLEASE DO READ OUT ,9
DO RESUME #3

(113) DO .1 <- .6
DO .2 <- #1
DO (1000) NEXT
DO .1 <- .5
DO .2 <- .3
DO (1010) NEXT
DO .1 <- '.3~.3'~#1
PLEASE DO FORGET .1
DO RESUME #1

(114) DO .1 <- '.6~.6'~#1
PLEASE DO FORGET .1
DO RESUME #1

(15) DO ,9SUB#1 <- #252
DO ,9SUB#2 <- #4
PLEASE DO READ OUT ,9
DO RESUME #2

Tốt đẹp duyên dáng. Điều này làm tôi mất một chút để tìm ra. Các số nhãn là một mớ hỗn độn và do đó phản ánh điều đó. Tôi sẽ không cố gắng giải thích điều này trừ khi có ai đó hỏi.

Nhiệm vụ 3

DO WRITE IN .5
DO WRITE IN .6

DO (1) NEXT

(1) PLEASE DO (3) NEXT
DO FORGET #1
DO (1) NEXT

(3) DO (4) NEXT
DO READ OUT .5
PLEASE GIVE UP

(4) DO .1 <- .5
DO .2 <- .6
PLEASE DO (1040) NEXT
DO .1 <- .3
DO .2 <- .6
PLEASE DO (1039) NEXT
DO .2 <- .3
DO .1 <- .5
DO (1010) NEXT
DO .5 <- .6
DO .6 <- .3
DO .1 <- '.6~.6'~#1
PLEASE DO FORGET .1
DO RESUME #1

Đây là một đơn giản hơn một chút. Vì ... sự kỳ lạ của INTERCAL, bạn phải nhập các số như thế này:

THREE FIVE

Ví dụ: để có GCD là 42 và 16, tôi nhập:

FOUR TWO
ONE SIX

Nó cũng in số bằng chữ số La Mã ... bởi vì đó là INTERCAL dành cho bạn!

1967 - APL

Năm 1957, tại Đại học Harvard, Ken Iverson bắt đầu phát triển một ký hiệu toán học cho thao tác mảng. Trong những năm 1960, ký hiệu của ông đã được phát triển thành ngôn ngữ lập trình tại IBM. Việc thực hiện một phần đầu tiên được tạo ra vào năm 1963 và thậm chí nó còn được sử dụng trong một trường trung học để dạy học sinh về các chức năng siêu việt. Việc triển khai đầy đủ, có thể sử dụng được phải đợi đến năm 1965. Trong hai năm, nó chỉ được IBM sử dụng nội bộ. Vào năm 1967, IBM đã phát hành cho công chúng một trình thông dịch APL chạy trên máy tính IBM 1130, đã hoàn thành vào năm 1966. Bạn có thể hiểu rằng thật khó để chọn một năm cho nó, tuy nhiên, tôi nghĩ rằng đó phải là năm 1967, vì đây là năm đầu tiên triển khai đầy đủ cho công chúng. Nếu bất cứ ai thực sự không đồng ý, tôi có thể thay đổi nó.

Mã nguồn cho APL \ 360, trực tuyến , như là một trình giả lập. Đây là những gì tôi đã sử dụng để kiểm tra các ví dụ này. Nó có từ năm 1967 và cùng với APL \ 1130 (đối với IBM 1130 đã nói ở trên), nó ít nhiều là bản gốc thực sự. Như mong đợi, nó rất nguyên thủy. Nó thiếu hỗ trợ cho niceties như chữ thường, bất kỳ nhà khai thác chỉ làm việc với các chức năng được xây dựng trong, và tập hợp các hàm dựng sẵn là rất thưa thớt (nói riêng, ∨là duy nhất or , và không không tăng gấp đôi như gcd). Bản gốc, mô tả đầy đủ có sẵn ở đây , tuy nhiên, tôi nhận thấy rằng phiên bản tôi có thậm chí không hoàn chỉnh đối với tài liệu đó, thiếu ⍎những thứ khác.

Tôi đã cung cấp các chương trình theo định dạng Unicode (để bạn có thể đọc chúng) và trong mã hóa ban đầu (để bạn có thể cắt và dán chúng vào cửa sổ APL của trình giả lập).

Không thể tin được, các chương trình này chạy chính xác mà không có bất kỳ thay đổi nào (ngoại trừ mã hóa) trong các phiên bản hiện đại của Dyalog, NARS2000 và GNU APL. Vì vậy, tôi đoán rằng tôi đã tìm thấy cách viết APL di động: cứ giả vờ là năm 1967!

Nhiệm vụ 1:

Unicode:

⎕←'APL WAS MADE IN 1967!'

APL \ 360:

L[Kapl was made in 1967ÝK

Nhiệm vụ 2:

Unicode:

⎕←' N'[1+((2⍴N)⍴(⍳N)∊1,N)∨(⍳N)∘.=⍳N←⎕]

APL \ 360:

L[K nK;1-::2Rn"R:In"E1,n"(:In"J.%In[L'

Nhiệm vụ 3:

Tôi đã giải quyết điều này theo cách đệ quy tiêu chuẩn. Về lý thuyết, bạn có thể làm một cái gì đó thông minh và định hướng theo mảng, như câu trả lời J; tuy nhiên, trên thực tế, điều đó có sử dụng bộ nhớ O (N) và nhanh chóng áp đảo phần cứng và phần mềm thời kỳ Điện hoa.

Unicode:

∇R←A GCD B
R←A
→(B=0)/0
R←B GCD B|A
∇

⎕←⎕ GCD ⎕

APL \ 360:

Gr[a gcd b
r[a
{:b%0"/0
r[b gcd bMa
G

L[L gcd L

1996 - Ocaml

Đã chờ đợi hơn một ngày để ai đó điền vào năm 1996, vì vậy tôi có thể điền vào Ruby. Vậy thì tại sao không học OCaml, có vẻ tương tự như haskell ...

Chào thế giới

print_endline "OCaml was made in 1996!";;

ASCII

let ascii n =
  let rec ascii' = function
    | 0 -> ()
    | i ->
        let s = "N" ^ String.make (n-2) ' ' ^ "N" in
        String.fill s (n-i) 1 'N';
        print_endline s;
        ascii' (i-1)
  in ascii' n;;

Chuỗi đột biến!

GCD

let rec gcd a b = if b = 0 then a else gcd b (a mod b);;

Không ==và infix mod, thật dễ thương

2005 - Mở đầu

Mở đầu là một ngôn ngữ rất thú vị, có mã nguồn bao gồm một số "tiếng nói" được thực thi song song và tôi thực sự thích giải quyết các vấn đề . Nó có nghĩa là đại diện ASCII của ngôn ngữ chị em Fugue , thực sự lấy các tệp .midi làm mã nguồn của nó và mã hóa các hướng dẫn được tìm thấy trong Prelude dưới dạng các quãng trong các giai điệu của giọng nói.

Mở đầu là khá tối giản, nhưng Turing hoàn thành (với điều kiện bạn đang sử dụng ít nhất 2 giọng nói). Như tôi đã nói, các giọng nói (dòng mã) được thực hiện đồng thời, từng cột. Mỗi giọng nói hoạt động trên ngăn xếp riêng của nó, được khởi tạo thành vô số số không. Mở đầu hỗ trợ các hướng dẫn sau:

0-9 ... Push the corresponding digit.
+   ... Add the top two numbers on the stack.
-   ... Subtract the top number from the one beneath.
#   ... Discard the top of the stack.
^   ... Copy the top value from the voice above.
v   ... Copy the top value from the voice below.
?   ... Read a number and push it onto the stack.
!   ... Print the top number (and pop it from the stack).
(   ... If the top of the stack is zero, jump past the matching ')'.
)   ... If the top of the stack is zero, jump to the column after the matching '('.

Một số lưu ý bổ sung:

• Các giọng nói đều theo chu kỳ, do đó, ^trên các bản sao giọng nói hàng đầu từ giọng nói phía dưới (và ngược lại).
• Nhiều ?và !trong cùng một cột được thực hiện từ trên xuống dưới.
• Theo đặc tả ngôn ngữ , ?và !đọc và viết các ký tự với mã ký tự tương ứng. Tuy nhiên, trình thông dịch Python cũng có một công tắc trong mã của nó để tự in các số. Đối với mục đích thử nghiệm, tôi thực sự đang sử dụng một phiên bản sửa đổi cũng có thể đọc số thay vì ký tự. Nhưng sự đồng thuận ở đây là đầu vào / đầu ra số thực sự có thể được đưa ra dưới dạng các giá trị byte, do đó những sửa đổi này là không cần thiết để thực hiện các chương trình hợp lệ xử lý các số.
• Phù hợp (và )không cần phải có cùng một giọng nói. Giọng nói sử dụng cho điều kiện là luôn luôn một trong những nơi (xuất hiện. Do đó, vị trí thẳng đứng của )hoàn toàn không liên quan.
• Do tính chất thực hiện đồng thời của Prelude, bất kỳ lệnh nào trong cùng một cột với a chỉ (được thực hiện một lần trước khi vòng lặp bắt đầu và bất kể vòng lặp có được nhập hay không. Tương tự, bất kỳ lệnh nào trong cùng một cột với a )được thực hiện ở cuối mỗi lần lặp, bất kể vòng lặp sẽ được thoát sau lần lặp này.

Trước tiên tôi sẽ chỉ cho bạn ba chương trình mà không cần bình luận nhiều. Bạn có thể tìm thấy giải thích rộng rãi dưới đây.

Các chương trình

"Chào thế giới!" Biến thể

9(1-)v98+^++!9v+!  v88++2+!^  ! ^9-3-! v      !    v2-!55+!
8 8+ !     7v+! 1v+!88+^+!^4-!^ v8-^ !!!9v+  !^9+9+!  v5+!
     ^98++4+! ^8-! ^4-   ^ #!^6-!    ^^  #5+! v    ^2-!1+!

Nếu bạn đang sử dụng trình thông dịch Python, hãy chắc chắn rằng NUMERIC_OUTPUT = False.

Nghệ thuật ASCII

      v2-(1-)v         
9(1-)?1-( v!  (1-55+!      0     (0)#  ))55+!
4-4+                  v^-#
     v!      v! v1-v!(1- ^(#^!0)# v! )v!
6 8+           v#

Để dễ sử dụng, chương trình này được hưởng lợi từ việc đọc đầu vào dưới dạng số, nhưng đầu ra không được là số. Vì vậy, nếu bạn đang sử dụng trình thông dịch Python đã sửa đổi, hãy đặt

NUMERIC_INPUT = True
NUMERIC_OUTPUT = False

GCD

?(                         v)
? (^-(0 # v   #       ^+0)#^ !
     ^^ (##v^v+)#  0 (0 )   
      1) ^ #  - 1+(#)#

Điều này được sử dụng tốt nhất với tất cả đầu vào / đầu ra số tức là

NUMERIC_INPUT = True
NUMERIC_OUTPUT = True

Giải thích

"Chào thế giới!" Biến thể

Điều này là khá đơn giản. Tôi đang sử dụng 3 giọng nói để liên tiếp tạo mã ký tự cho tất cả các ký tự Prelude was made in 2005!. Tôi bắt đầu bằng máy tính 8 + 9*8 = 80, đó là mã ký tự của P:

 9(1-)
 8 8+

Sau đó, tôi chủ yếu chỉ sao chép mã ký tự trước đó và cộng hoặc trừ sự khác biệt cho mã tiếp theo. Đây là mã, nhưng với mỗi !ký tự được thay thế bằng ký tự đang được in (và _cho khoảng trắng và %cho các chữ số):

9(1-)v98+^++r9v+u  v88++2+w^  _ ^9-3-a v      _    v2-%55+!
8 8+ P     7v+l 1v+e88+^+_^4-s^ v8-^ de_9v+  n^9+9+%  v5+%
     ^98++4+e ^8-d ^4-   ^ #a^6-m    ^^  #5+i v    ^2-%1+!

Bản cuối cùng 55+!in một dòng mới, chỉ vì nó đẹp hơn.

Một lưu ý phụ, số lượng giọng nói khá tùy ý cho nhiệm vụ này, nhưng 3 giọng nói khá thuận tiện vì đây là số lượng lớn nhất mà mọi giọng nói có thể truy cập trực tiếp vào nhau.

Nghệ thuật ASCII

      v2-(1-)v         
9(1-)?1-( v!  (1-55+!      0     (0)#  ))55+!
4-4+                  v^-#
     v!      v! v1-v!(1- ^(#^!0)# v! )v!
6 8+           v#

Với 5 giọng nói, đây chắc chắn là một trong những chương trình phức tạp nhất mà tôi đã viết cho đến nay. Các giọng nói đại khái có các mục đích sau:

1. Chỉ là một giọng nói trợ giúp lưu trữ N-1để sử dụng trong vòng lặp bên trong.
2. Đây là loại giọng nói "chính", đọc đầu vào, chứa một công tắc quan trọng và cũng chứa vòng lặp bên ngoài (tức là giọng nói trên các hàng).
3. Điều này lưu trữ một 32không gian in thuận tiện.
4. Cái này chứa vòng lặp bên trong (cái trên các cột).
5. Điều này lưu trữ một 78để thuận tiện in Ns.

Chúng ta hãy đi qua từng phần mã. Đầu tiên, tôi đang tạo 32như -4 + 9*4và 78như 6 + 9*8:

9(1-)
4-4+

6 8+

Bây giờ tôi đang in một N(vì chúng tôi luôn cần một cái) trong khi đọc đầu vào Nvà lưu trữ N-1và N-2trong hai giọng nói đầu tiên:

      v2-
     ?1-

     v!

Tiếp theo, có một "vòng lặp" được điều hòa trên N-1. Ở cuối vòng lặp, giọng nói thứ hai luôn luôn bị giảm xuống 0và vòng lặp thoát ra sau lần lặp đầu tiên. Vì vậy, về cơ bản, điều này chỉ if(N > 1){...}. Sau vòng lặp, chúng tôi sẽ in một dòng mới. Tóm lại, bây giờ chúng ta đã có khung sau:

      v2-
9(1-)?1-(                               )55+!
4-4+
     v!
6 8+

Trong điều kiện này, chúng tôi có N-2không gian đầu tiên và một không gian duy nhất Nđể hoàn thành hàng đầu tiên và chúng tôi cũng lưu trữ N-1trên giọng nói đầu tiên để sử dụng trong tương lai:

         (1-)v         
          v!  

             v!

Bây giờ thịt thực sự của mã. Đầu tiên, có một vòng lặp bên ngoài, in N-1các hàng. Đối với mỗi hàng, trước tiên chúng tôi in một dòng mới và một N. Sau đó, chúng tôi lặp lại N-2thời gian, in dấu cách hoặc Ns (nhiều hơn về sau). Và cuối cùng chúng tôi in một cái khác N:

               1-55+!  

                v1-v!(               )v!
               v#

Cuối cùng, phần thú vị: in từng hàng (và nhận vị trí Nbên phải). Thực sự không có if / other trong Prelude, vì vậy tôi phải tự xây dựng nó bằng hai vòng lặp trên các giọng nói khác nhau. Điều kiện có thể dễ dàng thu được bằng cách trừ biến vòng lặp bên trong và bên ngoài - chúng ta nhận được 0nếu chúng ta muốn in Nvà một cái gì đó khác không nếu chúng ta muốn in một khoảng trắng.

Ý tưởng cơ bản của if / other trong Prelude là đặt một vòng lặp sau giá trị liên quan - mã "if" (hoặc khác không) và thoát nó ngay lập tức bằng cách đẩy a 0. Trên một giọng nói khác, bạn giữ một giá trị khác không và một vòng lặp khác sau vòng lặp "nếu". Trong vòng lặp "nếu", bạn đặt số 0 lên trên giọng nói khác, để ngăn "người khác" được thực thi. Có một sự linh hoạt trong việc bạn đẩy các giá trị 0 lên trên các giá trị khác không hay đơn giản là loại bỏ giá trị khác không nếu có một số 0 bên dưới, nhưng đây là ý tưởng chung. Bạn cũng có thể phải thực hiện một số dọn dẹp sau đó, nếu bạn muốn tiếp tục sử dụng giọng nói có liên quan. Đây là những gì mã trông giống như:

                           0     (0)#
                      v^-#
                      1- ^(#^!0)# v! 

Và đó là nó!

GCD

Đây là "chỉ" một triển khai lặp lại của thuật toán Euclide. Nhưng modulo trong Prelude hơi khó chịu, chủ yếu là vì bạn không thể dễ dàng kiểm tra xem một số là dương hay âm. Mã này sử dụng một triển khai dấu hiệu tôi đã viết cách đây một thời gian . Tức là một phần lớn của mã chỉ biến một số thành -1, 0hoặc 1. Điều này sau đó có thể dễ dàng được biến thành một điều kiện cho các số dương hoặc âm bằng cách thêm hoặc bớt 1.

?(                         v)
? (^-(0 # v   #       ^+0)#^ !
     ^^ (##v^v+)#  0 (0 )   
      1) ^ #  - 1+(#)#

Vì vậy, chúng tôi đã có bốn tiếng nói lần này. Giọng nói đầu tiên chỉ cần theo dõi bvà chứa điều kiện kết thúc chính (tức là vòng lặp thoát khi btrở thành 0). Giọng nói thứ hai chứa avà với sự trợ giúp của giọng nói ba và bốn phép tính a % b, trước khi hoán đổi kết quả với giọng trước b. Cuối cùng, !bản in akhi b == 0.

Trước tiên, hãy nhìn vào phần dấu hiệu :

     (0 # v   #
     ^^ (##v^v+)#
      1) ^ #  -

Số đầu vào nđược tìm thấy trên giọng nói đầu tiên (giọng nói thứ hai trong chương trình đầy đủ). Kết quả sẽ kết thúc ở giọng nói dưới cùng. Hai giọng nói còn lại dự kiến ​​sẽ trống (tức là chứa đầy số không). Lưu ý rằng, nếu n == 0, sau đó cả hai vòng lặp được bỏ qua và giọng nói phía dưới vẫn chứa 0, chỉ là những gì chúng ta muốn.

Nếu nkhác không, vòng lặp nhỏ đầu tiên được nhập. Chúng tôi đẩy số 0 để thoát nó ngay lập tức, đặt hai bản sao nlên giọng giữa và một 1giọng nói phía dưới. Bây giờ, ý tưởng cơ bản là tăng một trong các bản sao ntrong khi giảm dần bản sao khác ncho đến khi một trong số chúng đạt 0. Trong khi làm như vậy, 1giọng nói ở phía dưới lật dấu hiệu của nó mọi lúc (điều này dễ dàng được thực hiện bằng cách trừ nó từ 0bên dưới nó trên ngăn xếp). Điều này được thiết lập sao cho khi một trong các số chạm 0, giọng nói phía dưới sẽ chứa dấu chính xác.

Bây giờ modulo được thực hiện bằng cách trừ btừ acho đến khi kết quả là âm tính. Khi điều đó xảy ra, chúng tôi thêm một blần nữa. Đó là bit này:

  (^-  signum         ^+0)#
       signum      0 (0 )   
       signum   1+(#)#

Lưu ý cấu trúc if / other ở phía dưới, tương tự như cái tôi đã sử dụng cho Nhiệm vụ 2.

2007 - Cào

Scratch là một ngôn ngữ được MIT tạo ra cho mục đích giáo dục. Tôi đã rất gắn bó với nó trong 5 năm; nhiều hơn về điều đó sau.

Tất cả những điều này có thể được xem ở đây .

Tôi đang rất vội vàng ngay bây giờ và sẽ giải thích các đoạn trích sau. Hy vọng rằng họ prety tự giải thích mặc dù.

Nhiệm vụ 1

Nhiệm vụ 2

Nhiệm vụ 3

Năm 1972 - C

Chúng ta đều biết về C, phải không? C được tạo ra tại Bell Labs, cùng với Unix. Unix phần lớn được viết bằng C. Tất cả các dẫn xuất Unix hiện đại vẫn chủ yếu được viết bằng cú pháp của C. C đã ảnh hưởng đến nhiều, nhiều ngôn ngữ lập trình. Nó có lẽ là ngôn ngữ lập trình lâu đời nhất vẫn được sử dụng rộng rãi cho sự phát triển mới.

Bản thân C là hậu duệ của B, mà tôi hy vọng cũng sẽ có trong danh sách này. Không có ngôn ngữ lập trình 'A': B là một biến thể của BCPL, đến lượt nó là một CPL bị tước bỏ. Không có ngôn ngữ nào trong số này đã từng rất phổ biến. Tuy nhiên, BCPL là ngôn ngữ trong đó chương trình "Hello World" đầu tiên được viết. Một sự thật thú vị khác là B đã có cả hai /* */và //bình luận, nhưng C đã bỏ các //bình luận. Sau đó, chúng được giới thiệu lại vào C với tiêu chuẩn C99.

Các chương trình C ở đây đã được thử nghiệm với trình biên dịch Unix V5 C, từ năm 1974. Đây là trình biên dịch C lâu đời nhất tôi có thể tìm và làm việc, và các chương trình này sẽ không biên dịch trên trình biên dịch C hiện đại. (Một trong những thay đổi được thực hiện là các toán tử đột biến như đã +=từng được viết=+ .)

#include <... >chưa tồn tại Không có nhiều thư viện tiêu chuẩn. Tôi đã phải viết riêng của tôi atoi. Tôi đã xem qua một số mã nguồn V5 để tìm ra những thứ được phép và những thứ không được phép. Phiên bản tôi đã sử dụng là phiên bản đầu tiên bao gồm structs, nhưng vì tôi không sử dụng phiên bản đó và cú pháp dường như không thay đổi nhiều cho đến V7 (như K & R C), nên phiên bản này cũng có thể hoạt động với các phiên bản trước đó.

Tôi đã cố hết sức để viết mã của mình theo cùng kiểu với mã nguồn V5 sử dụng. (Tuy nhiên, đó không phải là phù hợp khủng khiếp.)

Xem ở đây để biết các liên kết đến Unix V5, trình giả lập và hướng dẫn về cách chạy nó trên một máy tính hiện đại.

Nhiệm vụ 1

main()
{
   write(1, "C was made in 1972!\n", 20);
}

Nhiệm vụ 2

atoi(str)
char *str;
{
    register num, digit;
    while (digit = *str++) {
        num =* 10;
        num =+ digit - '0';

    }
    return num;
}

N(n)
{
    register x, y;
    for (y=1; y<=n; y++) {
        for (x=1; x<=n; x++) {
            write(1, " N"+(x==1||x==y||x==n), 1);
        }
        write(1, "\n", 1);
    }
}

main(argc, argv)
char *argv[];
{
    N(atoi(argv[1]));
}

Nhiệm vụ 3

atoi(str)
char *str;
{
    register num, digit;
    while (digit = *str++) {
        num =* 10;
        num =+ digit - '0';
    }
    return num;
}

gcd(a, b)
{
    return b ? gcd(b, a%b) : a;
}

main(argc, argv)
char *argv[];
{
    printf("%d\n", gcd(atoi(argv[1]), atoi(argv[2])));
}

2009 - Idris

Idris là một ngôn ngữ chức năng thuần túy được đánh máy, nhấn mạnh rằng trên thực tế có thể sử dụng được cho các ứng dụng trong thế giới thực, ngoài việc cung cấp các khả năng chứng minh cực kỳ nghiêm ngặt có thể đạt được với các loại phụ thuộc.

Nhiệm vụ 1

module Main

main : IO ()
main = putStrLn "Idris was made in 2009!"

Nhiệm vụ 2

module InN

import Data.Fin
import Data.Vect

genN : Vect n (Vect n Char)
genN = [[ if inN x y then 'N' else ' ' | x<-range ]| y<-range ]

||| Helper function, determines whether the char at coordinate (x,y)
||| is part of the letter:
inN : Fin n -> Fin n -> Bool
inN {n=S _} x y = x==0 || x==y || x==last

Đây không phải là một chương trình mà chỉ là một hàm (chính xác hơn là giá trị phụ thuộc ), tạo ra chữ N mong muốn dưới dạng một mảng hai chiều.

$ idris ascii-n.idr 
     ____    __     _                                          
    /  _/___/ /____(_)____                                     
    / // __  / ___/ / ___/     Version 0.9.17.1-
  _/ // /_/ / /  / (__  )      http://www.idris-lang.org/      
 /___/\__,_/_/  /_/____/       Type :? for help               

Idris is free software with ABSOLUTELY NO WARRANTY.            
For details type :warranty.
Type checking ./ascii-n.idr
*ascii-n> genN {n=4}
[['N', ' ', ' ', 'N'],
 ['N', 'N', ' ', 'N'],
 ['N', ' ', 'N', 'N'],
 ['N', ' ', ' ', 'N']] : Vect 4 (Vect 4 Char)

Nhiệm vụ 3

module gcd

gcd' : Nat -> Nat -> Nat
gcd' a Z = a
gcd' a b = gcd' b $ a`mod`b

Lưu ý rằng tôi phải chọn tên gcd'vì gcdnó đã được xác định trong khúc dạo đầu của Idris.

Type checking ./gcd.idr
*gcd> gcd' 8 12
4 : Nat
*gcd> gcd' 12 8
4 : Nat
*gcd> gcd' 234 876
6 : Nat

2014 - Pyth

Vì chúng tôi có CJam, chúng tôi cũng có thể có Pyth cho sự hoàn chỉnh :)

Pyth là một ngôn ngữ chơi gôn của @isaacg , nó được biên dịch thành Python. Nó đáng chú ý vì là thủ tục và sử dụng ký hiệu tiền tố. Pyth lần đầu tiên xuất hiện vào khoảng tháng 6 năm 2014 .

"Chào thế giới!" Biến thể

"Pyth was made in 2014!

Lưu ý việc thiếu trích dẫn kết thúc, là tùy chọn nếu chương trình Pyth kết thúc bằng một chuỗi.

Nghệ thuật ASCII

VQ+\Nt+P++*Nd\N*t-QNd\N

Hãy thử trực tuyến . Python tương đương là:

Q = eval(input())
for N in range(Q):
    print("N"+((" "*N+"N"+(Q-N-1)*" ")[:-1]+"N")[1:])

Hoặc mở rộng (dòng đầu tiên và thứ ba là ẩn):

Q = eval(input())                                        # 
for N in range(Q):                                       #   VQ
    print(                                          )    # 
          "N"+                                           #     +\N
              (                                )[1:]     #        t
                                           +"N"          #         +              \N
               (                     )[:-1]              #          P
                         +(Q-N-1)*" "                    #           +      *t-QNd
                     +"N"                                #            +   \N
                " "*N                                    #             *Nd

GCD

=GvwWQAGQ,Q%GQ)G

Chương trình này sử dụng thuật toán Euclide và lấy hai số cách nhau bởi một dòng mới. Hãy thử trực tuyến .

Q = eval(input())     #
G = eval(input())     #    =Gvw
while Q != 0:         #        WQ
  G, Q = Q, G % Q     #          AGQ,Q%GQ)
print(G)              #                   G

i.uQthậm chí còn ngắn hơn nếu chúng ta sử dụng nội dung cho GCD. Điều này tương đương với print(gcd(*eval(input())))(lấy hai số được phân tách bằng dấu phẩy làm đầu vào).

1964 - CƠ SỞ

BASIC là một nhóm các ngôn ngữ lập trình cấp cao, đa mục đích có triết lý thiết kế nhấn mạnh đến tính dễ sử dụng. Năm 1964, John G. Kemeny và Thomas E. Kurtz đã thiết kế ngôn ngữ BASIC ban đầu tại Đại học Dartmouth ở New Hampshire. Họ muốn cho phép sinh viên trong các lĩnh vực khác ngoài khoa học và toán học sử dụng máy tính.

Tôi đang xem hướng dẫn này trên BASIC từ năm 1964 và trình giả lập này của Hệ thống chia sẻ thời gian Darthmouth mà nó đã chạy. Máy chủ vẫn hoạt động, nhưng thật đáng buồn, việc đăng ký tài khoản dường như là không thể. Hiện tại, các chương trình này nên hoạt động trên lý thuyết:

Nhiệm vụ 1

10 PRINT "BASIC WAS MADE IN 1964"
20 END

Nhiệm vụ 2

10 READ N
15 FOR Y = 1 TO N STEP 1
20 FOR X = 1 TO N STEP 1
25 IF X = 1 THEN 50
30 IF X = N THEN 50
35 IF X = Y THEN 50
40 PRINT " ",
45 GO TO 55
50 PRINT "N",
55 NEXT X
60 PRINT
65 NEXT Y
70 DATA 5
75 END

Xuất ra một cái gì đó như:

N                       N
N     N                 N
N           N           N
N                 N     N
N                       N

Lưu ý cách đầu vào được nhập vào như một phần của chương trình ( 70 DATA 5); các READcách hướng dẫn ở đầu lấy về dữ liệu từ đó. Không có nối chuỗi, nhưng phần 3.1 của hướng dẫn sử dụng mô tả cách ghi PRINTkết quả vào "vùng" được lập bảng trên đầu ra.

Nhiệm vụ 3

Phiên bản chậm của thuật toán Euclid:

10 READ A, B
20 IF A = B THEN 80
30 IF A < B THEN 60
40 LET A = A - B
50 GO TO 20
60 LET B = B - A
70 GO TO 20
80 PRINT A
85 DATA 144, 250
90 END

Xuất ra:

2

2010 - WTFZOMFG

WTFZOMFG là một ngôn ngữ bí truyền dựa trên Brainfuck. Nó được tạo ra bởi Jay Songdahl vào năm 2010. "WTFZOMFG" là viết tắt của "What That Function? Zen Optimized Maloph File Gophers!" .

Đây là một trình biên dịch cho các hệ thống * nix .

Nhiệm vụ 1

'WTFZOMFG was made in 2010!\n"

Nhiệm vụ 2

/&(-.N%3 >&>s-{-(-. ).N}>{-(-. ).N}_0 '\n")

Giải trình:

Lấy làm tiếc. Tôi không giỏi viết lời giải thích.

/                                           # read the number and store it in cell 0
 &                                          # copy it to cell 1
  (                                         # loop while cell 0 isn't 0
   -                                        # decrease the value of cell 0
    .N                                      # print "N"
      %3                                    # copy cell 0 to cell 3
                                            # a space must be added after the number. I don't know if it's a bug of the compiler or a feature.
         >                                  # move to cell 1
          &                                 # copy cell 1 to cell 2
           >                                # move cell 2
            s                               # let cell 2 = cell 2 - cell 3
             -                              # decrease the value of cell 2
              {                             # if cell 2 isn't 0
               -                            # decrease the value of cell 2
                (-. )                       # while cell 2 isn't 0, decrease it and print " "
                     .N                     # print "N"
                       }                    # end if
                        >                   # move cell 3
                         {                  # if cell 3 isn't 0
                          -                 # decrease the value of cell 3
                           (-. )            # while cell 3 isn't 0, decrease it and print " "
                                .N          # print "N"
                                  }         # end if
                                   _0       # move to cell 0
                                      '\n"  # print a newline
                                          ) # 

Nhiệm vụ 3

/>>/(<<&>dm<s&>>%0 <&>)<<\

Thuật toán Euclide. WTFZOMFG không có lệnh cho mod, vì vậy tôi phải sử dụng d(chia), m(nhân) và s(trừ).

2009 - Đi

Go là ngôn ngữ lập trình được phát triển bởi Google. Sự phát triển bắt đầu vào năm 2007, nhưng Go đã được công bố vào tháng 11 năm 2009.

Go là một ngôn ngữ gõ tĩnh chịu ảnh hưởng của C, trong đó nhấn mạnh đến tính đơn giản, đơn giản và an toàn.

Nhiệm vụ 1:

package main
import "fmt"

func main(){
    fmt.Println("Go was made in 2009!")
}

Dòng đầu tiên khai báo gói mã. Ngay cả một ví dụ đơn giản như in một dòng cũng cần phải là một phần của một gói. Và thực thi luôn được gọi main.

Nhiệm vụ 2:

package main

import (
        "fmt"
        "strings"
)

func main(){
    var n int
    fmt.Scan(&n)

    for i := 0; i < n; i++ {
        a := make([]string, n, n)
        for j := 0; j < n; j++ { a[j] = " " }

        a[0] = "N"
        a[i] = "N"
        a[n-1] = "N"

        s := strings.Join(a, "")
        fmt.Println(s)
    }
}

Go có một khai báo biến khá súc tích ( i := 0giống như var i int = 0) và trình biên dịch xác định loại. Đây thường là một tính năng phổ biến hơn trong các ngôn ngữ động. Sử dụng ký hiệu ngắn này cũng rất dễ dàng để gán các hàm cho biến ( f := func(x int) int {/* Code */}) và tạo Đóng.

Nhiệm vụ 3:

package main

import "fmt"

func gcd(a, b int) int {
    for b != 0 {
        a, b = b, a%b
    }
    return a
}

func main(){
    var a, b int
    fmt.Scan(&a)
    fmt.Scan(&b)

    fmt.Println(gcd(a, b))
}

Ở đây bạn có thể thấy a, b = b, a%bcú pháp, đó là thực sự tốt đẹp. Tôi không biết tên chính xác, nhưng trong Python nó được gọi là bộ giải nén. Sử dụng cùng một cách bạn có thể trả về nhiều giá trị từ một hàm ( func f() (int, string) { return 42, "Hallo"}).

Một điều khác xảy ra trong mã này là vòng lặp. Vòng lặp for là vòng lặp duy nhất trong Go. Vòng lặp while hoặc vòng lặp do-while không tồn tại. Nhưng bạn có thể dễ dàng tạo một vòng tương đương cho vòng lặp while for condition {}hoặc vòng lặp vô hạn for {}.

1991 - Con trăn

Lịch sử ngôn ngữ

Vào cuối những năm 1980, Guido van Rossum bắt đầu nghĩ ra Python như một sở thích. Tên của nó xuất phát từ Flying Circus của Monty Python, một chương trình truyền hình của Anh mà Rossum là một người hâm mộ. Việc triển khai Python đầu tiên bắt đầu vào năm 1989 và được phát hành vào năm 1991. Nó đã trở nên phổ biến trong những năm qua, trở thành ngôn ngữ được lựa chọn cho nhiều khóa học khoa học máy tính giới thiệu.

"Chào thế giới!" Biến thể

print("Python was made in 1991!")

Lưu ý các dấu ngoặc đơn xung quanh đầu vào print. Mặc dù cú pháp này hoạt động trong Python 2, thông thường trong Python 2, bạn sẽ bỏ qua các dấu ngoặc đơn này. Tuy nhiên, chúng được yêu cầu trong Python 3. Theo đề xuất của Zach Gates, dấu ngoặc đơn được sử dụng xuyên suốt để đảm bảo rằng mã được trình bày ở đây sẽ hoạt động trên các phiên bản.

Nghệ thuật ASCII

def asciin(n):
    if n == 1:
        print("N")
    else:
        print("N" + " "*(n-2) + "N")

        for i in range(2, n):
            print("N" + " "*(i-2) + "N" + " "*(n-i-1) + "N")

        print("N" + " "*(n-2) + "N")

Các chức năng được xác định bằng cách sử dụng def. Nối chuỗi được thực hiện bằng cách sử dụng +và lặp lại chuỗi với *.

GCD

def gcd(a, b):
    if b == 0:
        return(a)
    else:
        return(gcd(b, a % b))

Lưu ý rằng Python yêu cầu khoảng trắng có cấu trúc.

1968 - Algol 68

Algol 68 được Nhóm làm việc IFIP 2.1 định nghĩa là người kế thừa Algol 60.

Nó là một ngôn ngữ định hướng biểu thức trong đó mọi thứ đều có giá trị. Nó cũng là trực giao, trong đó bạn có thể sử dụng bất kỳ cấu trúc nào theo bất kỳ cách nào. Điều này có nghĩa là các biểu thức có thể nằm trên RHS và LHS của một bài tập, chẳng hạn.

Tất cả các cấu trúc điều khiển có dạng viết tắt cũng như dạng dài sử dụng biểu thức. Nó cũng cho phép các định nghĩa của các nhà khai thác.

Các mục tiêu của ngôn ngữ được trích dẫn là:

Mục đích và nguyên tắc thiết kế chính của ALGOL 68:

• Tính đầy đủ và rõ ràng của mô tả
• Thiết kế trực giao,
• Bảo vệ,
• Hiệu quả
• Kiểm tra chế độ tĩnh
• Phân tích cú pháp độc lập với chế độ
• Biên soạn độc lập
• Tối ưu hóa vòng lặp
• Đại diện - trong bộ ký tự tối thiểu và lớn hơn

Các chương trình này đã được thử nghiệm với trình thông dịch Algol 68 Genie , đây là một triển khai hoàn chỉnh của ngôn ngữ.

Một số tính năng mà các lập trình viên hiện đại có thể thấy khác nhau, đó là các câu lệnh trống không được phép. Bạn không thể chỉ cần thêm ;ở khắp mọi nơi. Bạn phải sử dụng SKIPcâu lệnh nếu bạn muốn rõ ràng không có gì. Nó cũng cho phép mã hóa các chương trình đồng thời rất dễ dàng. Algol 68, đáng chú ý, đã sử dụng các từ khóa ngược làm dấu chấm dứt, chẳng hạn như esac , od , fi , v.v.

Ngôn ngữ có một đại diện được sử dụng để viết mã sử dụng nhiều phông chữ đại diện cho các từ khóa in đậm và ví dụ như chữ in nghiêng . Tại thời điểm đó, và có lẽ vẫn vậy, không có trình biên dịch nào thực hiện tính năng này của thiết kế. Ngôn ngữ cho phép một số biểu diễn cụ thể khác nhau của các chương trình sử dụng các chế độ vuốt . Điều này cho phép các chương trình được chuẩn bị bằng cách sử dụng các bộ ký tự giới hạn, chẳng hạn như có thể được tìm thấy trong các máy tính vào những năm 1960. Hãy xem xét một đoạn chương trình ngắn, sẽ được biểu diễn dưới dạng:

nếu tôi < 0 thì bỏ qua fi

Điều này có thể được chuẩn bị cho một trình biên dịch ở chế độ vuốt chính như:

'IF' I 'LT' 0 'THEN' 'SKIP' 'FI'

Trong chế độ chấm chấm, đây sẽ là:

.IF I .LT 0 .THEN .SKIP .FI

Trong trường hợp chế độ vuốt, đây sẽ là:

IF i < 0 THEN SKIP FI

Tôi rất thích ngôn ngữ này khi tôi làm việc trên một trong những triển khai trình biên dịch, cũng như lập trình trong đó dành riêng cho nhiều năm.

Nhiệm vụ 1

print (("Algol 68 được sản xuất năm 1968!", dòng mới ))

Điểm cần lưu ý ở đây là dấu ngoặc kép. Điều này là do in là một hàm có một đối số duy nhất là một mảng có độ dài thay đổi của sự kết hợp của tất cả các loại. Dấu ngoặc trong là hàm tạo mảng. Đây là cách đa hình được xử lý trong ngôn ngữ gõ mạnh này.

Trong trường hợp chế độ vuốt:

print (("Algol 68 was made in 1968!", newline))


C:\>a68g HelloWorld.a68
Algol 68 was made in 1968!

Nhiệm vụ 2

     int n ;
     đọc (( n ));
     với i từ 1 đến n làm
          cho j từ 1 đến n làm
               ¢ ở đây chúng tôi sử dụng mệnh đề IF viết tắt ¢
               print ((( j = 1 OR j = i OR j = n |
                    "N"
               |
                    ""
               )))
          od ;
     in (( dòng mới))
     od

Trong trường hợp chế độ vuốt:

 INT n;
 read ((n));
 FOR i FROM 1 TO n DO
        FOR j FROM 1 TO n DO
            CO here we use an abbreviated IF clause CO
            print (( ( j = 1 OR j = i OR j = n |
                 "N"
            |
                 " "
            ) ))
        OD ;
        print ((newline))
    OD

C:\>a68g ASCIIart.a68
8
N      N
NN     N
N N    N
N  N   N
N   N  N
N    N N
N     NN
N      N

Nhiệm vụ 3

     ¢ chúng ta có thể xác định các nhà khai thác của chúng ta trong Algol 68 ¢
     op % = ( int một , b ) int :
          (( b = 0 |
               một
          |
               b % ( một mod b )
          ));
     int i , j ;
     đọc (( i , j ));
     in (( i % j , dòng mới ))

Trong trường hợp chế độ vuốt:

COMMENT we can define our own operators in Algol 68 COMMENT
OP % = ( INT a, b) INT:
    ((b = 0 |
        a
    |
       b % (a MOD b)
    ));
INT i,j;
read((i,j));
print(( i % j , newline))


C:\>a68g GCD.a68
4 12
         +4

1962 - SNOBOL

"Ngôn ngữ định hướng và cộng hưởng". Lúc đầu, rõ ràng được gọi là Thông dịch viên biểu hiện tượng trưng, ​​'SEXI', sau đó phải được thay đổi để ngăn chặn những người mọt sách thời đại 1960 bị đỏ mặt khi nộp công việc. Câu chuyện có thật.

Đây là một trong những ngôn ngữ đầu tiên có thể xử lý các chuỗi và các mẫu nguyên bản. Thật vậy, phiên bản đầu tiên của SNOBOL có chuỗi là kiểu dữ liệu duy nhất của nó . Toán học sau đó được thực hiện bằng cách phân tích cú pháp. Việc triển khai ban đầu được thực hiện trên IBM 7090. Có vẻ như nó đã mất từ ​​lâu, ít nhất, tôi không thể tìm thấy nó. Những gì tôi đã tìm thấy là bài báo gốc mô tả nó cũng như một trình thông dịch SNOBOL3 trong Java, có thể chạy trên một máy tính hiện đại .

SNOBOL đầu tiên có khá nhiều chỉ khớp mẫu và số học cơ bản. SNOBOL 3 sau đó đã thêm các chức năng và thay đổi I / O, nhưng dường như vẫn tương thích ngược. SNOBOL 4 đã thay đổi cú pháp và từ đó, nó đã phát triển thành Biểu tượng , giữ cho mẫu phù hợp nhưng gần như trông giống như một ngôn ngữ lập trình "bình thường".

Các chương trình tôi đã viết chỉ sử dụng chức năng được mô tả trong bài báo gốc, do đó, nên hoạt động với SNOBOL ban đầu ngoại trừ I / O, tôi đã làm theo kiểu SNOBOL3 để trình thông dịch Java có thể chạy chúng. Từ bài báo, có vẻ như sự khác biệt là SNOBOL1 sử dụng khớp mẫu với một SYSbiến đặc biệt , trong khi SNOBOL3 sử dụng biến đầu vào và đầu ra:

• Đầu vào:
  • 1 SYS .READ *DATA*
  • 3 DATA = SYSPPT
• Đầu ra:
  • 1 SYS .PRINT 'A STRING' AND VARIABLES
  • 3 SYSPOT = 'A STRING' AND VARIABLES

Thực hiện những thay thế này sẽ giúp bạn trở thành 'SNOBOL' thực sự 1. Tất nhiên, sau đó bạn không thể chạy nó.

Nhiệm vụ 1

START   SYSPOT = 'SNOBOL WAS MADE IN 1962!'

Nhiệm vụ 2

Điều này cho thấy toán học, xử lý chuỗi và kiểm soát dòng chảy. SNOBOL3 có các chức năng hữu ích, muốn EQkiểm tra sự bình đẳng; SNOBOL ban đầu thì không, vì vậy tôi đã không sử dụng chúng.

* READ N FROM INPUT
START   SYSPOT = 'SIZE?'
        SZ = SYSPPT

* INITIALIZE
        CS = ''
        ROW = '0'

* OUTPUT PREVIOUS ROW AND START NEXT ONE
ROW     COL = '0'
        SYSPOT = CS
        CS = ''

COL     SUCC = 'N'
        EQ1 = COL
        FAIL = 'CHKE'
        EQ2 = '0'         /(EQUAL)
CHKE    FAIL = 'CHKR'
        EQ2 = SZ - '1'    /(EQUAL)
CHKR    FAIL = 'SPACE'
        EQ2 = ROW         /(EQUAL)

* CONCATENATE THE RIGHT CHARACTER TO THE CURRENT LINE         
SPACE   CS = CS ' '       /(NEXT)
N       CS = CS 'N'       /(NEXT)

* FOR NUMBERS, SUBSTRING MATCH IS ENOUGH IF IT IS KNOWN A<=B
NEXT    COL = COL + '1'
        COL SZ            /F(COL)
        ROW = ROW + '1'
        ROW SZ            /F(ROW)S(FIN)

* THERE SEEMS TO BE NO EQUALITY CHECK, JUST SUBSTRING MATCHING
* OF COURSE, EQ1 == EQ2 IFF EQ1 CONTAINS EQ2 AND VICE VERSA
* THIS ALSO ILLUSTRATES INDIRECTION
EQUAL   EQ1 EQ2           /F($FAIL)
        EQ2 EQ1           /S($SUCC)F($FAIL)

* OUTPUT THE LAST LINE
FIN     SYSPOT = CS     

Nhiệm vụ 3

Đầu tiên, một nhàm chán. Điều duy nhất cần lưu ý là kiểm tra nhỏ hơn kiểm tra, cho thấy chính xác SNOBOL định hướng chuỗi thực sự là gì: (B - A) '-'có nghĩa là "kết quả của BA có chứa một điểm trừ không?". SNOBOL3 cũng có thể làm được LE(B,A), nhưng SNOBOL 1 thì không thể (ít nhất là bài báo không đề cập đến nó).

* READ A AND B
START   SYSPOT = 'A?'
        A = SYSPPT
        SYSPOT = 'B?'
        B = SYSPPT

* GCD LOOP
STEP    '0' (A - B)          /S(DONE)
        (B - A) '-'          /S(AB)F(BA)
AB      A = A - B            /(STEP)
BA      B = B - A            /(STEP)
DONE    SYSPOT = 'GCD: ' A

Tất nhiên, khi bạn có một ngôn ngữ hoàn toàn dựa trên các chuỗi và khớp mẫu, sẽ thật đáng tiếc nếu không thực sự sử dụng khớp mẫu và thay thế. Vì vậy, đây là một trong những GCD dựa trên unary, bao gồm các thói quen để chuyển đổi sang và từ unary.

* READ A AND B
START   SYSPOT = 'A?'
        A = SYSPPT
        SYSPOT = 'B?'
        B = SYSPPT

* CONVERT TO UNARY
        UNA.IN = A
        UNA.FIN = 'ADONE'          /(UNA)
ADONE   A = UNA.R
        UNA.IN = B
        UNA.FIN = 'BDONE'          /(UNA)
BDONE   B = UNA.R


* USE STRING MATCHING TO FIND GCD
STEP    '' B                       /S(GDONE)
MATCH   A B =                      /S(MATCH)
        C = B
        B = A
        A = C                      /(STEP)

* CONVERT BACK TO DECIMAL
GDONE   DEC.IN = A
        DEC.FIN = 'DONE'           /(DEC)
DONE    SYSPOT = 'GCD: ' DEC.R     /(FIN)

***************************** 
* DECIMAL TO UNARY SUBROUTINE
UNA     UNA.R =
UNA.DGT UNA.IN *.DGT/'1'* =        /F($UNA.FIN)
        .X = UNA.R
        UNA.R =
UNA.MUL .X *.Y/'1'* =              /F(UNA.ADD)
        UNA.R = UNA.R '##########' /(UNA.MUL)
UNA.ADD '1' .DGT                   /S(UNA.1)
        '2' .DGT                   /S(UNA.2)
        '3' .DGT                   /S(UNA.3)
        '4' .DGT                   /S(UNA.4)
        '5' .DGT                   /S(UNA.5)
        '6' .DGT                   /S(UNA.6)
        '7' .DGT                   /S(UNA.7)
        '8' .DGT                   /S(UNA.8)
        '9' .DGT                   /S(UNA.9)
        '0' .DGT                   /S(UNA.DGT)
UNA.1   UNA.R = UNA.R '#'          /(UNA.DGT)
UNA.2   UNA.R = UNA.R '##'         /(UNA.DGT)
UNA.3   UNA.R = UNA.R '###'        /(UNA.DGT)
UNA.4   UNA.R = UNA.R '####'       /(UNA.DGT)
UNA.5   UNA.R = UNA.R '#####'      /(UNA.DGT)
UNA.6   UNA.R = UNA.R '######'     /(UNA.DGT)
UNA.7   UNA.R = UNA.R '#######'    /(UNA.DGT)
UNA.8   UNA.R = UNA.R '########'   /(UNA.DGT)
UNA.9   UNA.R = UNA.R '#########'  /(UNA.DGT)

*****************************
* UNARY TO DECIMAL SUBROUTINE
DEC     DEC.R =
DEC.DGT '' DEC.IN                  /S($DEC.FIN)
        .X = DEC.IN
        DEC.IN =
DEC.DIV .X '##########' =          /F(DEC.ADD)
        DEC.IN = DEC.IN '#'        /(DEC.DIV)
DEC.ADD '' .X                      /S(DEC.0)
        '#' .X                     /S(DEC.1)
        '##' .X                    /S(DEC.2)
        '###' .X                   /S(DEC.3)
        '####' .X                  /S(DEC.4)
        '#####' .X                 /S(DEC.5)
        '######' .X                /S(DEC.6)
        '#######' .X               /S(DEC.7)
        '########' .X              /S(DEC.8)
        '#########' .X             /S(DEC.9)
DEC.0   DEC.R = '0' DEC.R          /(DEC.DGT)
DEC.1   DEC.R = '1' DEC.R          /(DEC.DGT)
DEC.2   DEC.R = '2' DEC.R          /(DEC.DGT)
DEC.3   DEC.R = '3' DEC.R          /(DEC.DGT)
DEC.4   DEC.R = '4' DEC.R          /(DEC.DGT)
DEC.5   DEC.R = '5' DEC.R          /(DEC.DGT)
DEC.6   DEC.R = '6' DEC.R          /(DEC.DGT)
DEC.7   DEC.R = '7' DEC.R          /(DEC.DGT)
DEC.8   DEC.R = '8' DEC.R          /(DEC.DGT)
DEC.9   DEC.R = '9' DEC.R          /(DEC.DGT)

FIN     START

2012 - TypeScript

TypeScript là ngôn ngữ lập trình mã nguồn mở và miễn phí được phát triển và duy trì bởi Microsoft.

Mục tiêu chính là: Bất kỳ trình duyệt. Bất kỳ máy chủ lưu trữ. Bất kỳ hệ điều hành. Mã nguồn mở. Nó được phát hành vào tháng 10 năm 2012

Xin chào TypeScript

Task1(name:string,year:number) {
    return name + " was made in "+ year +"!";
}

Nghệ thuật ASCII

Task2(n:number,separator:string,space:string) {
    var result:string = "";
    for (var k = 0; k < n; k++)
    {
        for (var j = 0; j < n; j++)
        {
            var i = ((n * k) + j) % n;
            result+=(i == 0 || i == n - 1 || i == k) ? "N" : space;
        }
        result+=separator;
    }
    return result;
}

GCD

Task3(a:number,b:number) {
    while (a != 0 && b != 0)
        {
            if (a > b)
                a %= b;
            else
                b %= a;
        }

        if (a == 0)
            return b;
        else
            return a;
}

thử nó trực tuyến , và screencast của nó.

2011 - Phi tiêu

Dart là một ngôn ngữ lập trình mã nguồn mở được phát triển bởi Google, được phát triển để thay thế cho Javascript (mặc dù nó được biên dịch thành javascript). Nó đã được Google công bố vào năm 2011 trong hội nghị GOTO.

"Chào thế giới!" Biến thể:

main() {
  print('Dart was made in 2011!');
}

Nghệ thuật ASCII N:

Phương pháp Bruteforce, chạy ở 0 (n²), nhưng nó không thực sự quan trọng trừ khi bạn sử dụng một số khổng lồ.

asciiN(int number){
    if(number == 1){
        print('N');
    }else{
        for(var i = 1; i <= number; i++){
            String currentLine = "";
            for(var j = 1; j <= number; j++){
                if(j==1 || j == number || j == i){
                    currentLine = currentLine + "N";
                }else{
                    currentLine = currentLine + " ";
                }
            }
            print(currentLine);
        }
    }
}

GCD

phương pháp Euclid đơn giản được chuyển từ Snap! ví dụ trên.

int gcd(int first, int second){
if(second > first){
   return gcd(second, first);
    }else{
        if(first == 0){
            return second;
        }else{
            if(second ==0){
                return first;
            }else{
                return gcd(second, first-second);
            }
        }
    }
}

2010 - Rỉ

Rust là một mục đích chung, đa mô hình, ngôn ngữ lập trình được biên dịch được phát triển bởi Mozilla Research. Nó được thiết kế để trở thành một "ngôn ngữ an toàn, đồng thời, thực tế", hỗ trợ các phong cách thuần túy chức năng, diễn viên đồng thời, bắt buộc theo thủ tục và hướng đối tượng. Wikipedia

Nhiệm vụ 1

fn main()
{
    println!("Rust was made in 2010!");
}

Nhiệm vụ 2

fn main()
{
    // get commandline arguments
    // "test 3"
    let args : Vec<_> = std::env::args().collect();

    // convert 2nd argument to integer
    let n = u32::from_str_radix( args[1].as_ref(), 10 ).unwrap();
    print_n( n );
}

fn print_n( n: u32 )
{
    for y in range( 0, n )
    {
        for x in range( 0, n )
        {
            if x == 0 || x == y || x + 1 == n
            {
                print!("N");
            }
            else
            {
                print!(" ");
            }
        }
        println!("");
    }
}

Giải trình:

if x == 0 || x == y || x + 1 == n

chỉ cẩn thận khi in dọc (trái và phải |) và đường chéo ( \)

Nhiệm vụ 3

triển khai đơn giản Euclidean_alacticm

fn main()
{
    // get commandline arguments
    // "test 453 3"
    let args : Vec<_> = std::env::args().collect();

    // convert 2nd and 3rd argument to integers
    let a = u32::from_str_radix( args[1].as_ref(), 10 ).unwrap();
    let b = u32::from_str_radix( args[2].as_ref(), 10 ).unwrap();
    let g = gcd( a, b );
    println!( "GCD of {} and {} is {}", a, b, g );
}

fn gcd( mut a: u32, mut b: u32 ) -> u32
{
    while b != 0
    {
        let c = a % b;
        a = b;
        b = c;
    }
    return a;
}

2015 - Muffin MC

Muffin MC là một ngôn ngữ vĩ mô hoàn chỉnh, hài hước (nhưng nghiêm túc), đầy đủ chức năng và tối giản được viết bởi Franck Porcher ( http://franckys.com ) vào giữa tháng 2 năm 2015 vì không cần thiết như một công cụ (nhanh chóng) để trao quyền bảng tính được sử dụng làm bộ điều khiển mặt trước duy nhất để thí điểm và điều khiển tất cả các hoạt động liên quan đến hàng tồn kho được liên kết với trang web thương mại dựa trên Prestashop cho một thương hiệu thời trang Tahiti mới: Mutiny Tahiti ( http://mutinytahiti.com - sắp ra mắt ra mắt).

Muffin MC là viết tắt của MU nhỏ F unctional F lexible TRÊN dòng M Acro C ommand ngôn ngữ.

Để đáp ứng các yêu cầu của chúng tôi, các tính năng cốt lõi của Muffin MC đã được thiết kế xung quanh các cấu trúc ngữ nghĩa tích hợp cấp 1 linh hoạt và hiệu quả như các trình vòng lặp , đánh giá lười biếng , đa chức năng , chuỗi sản phẩm .

Muffin MC rút ra nguồn gốc của nó trong lập trình chức năng (thực dụng), FLisp và Perl. Nó hoàn toàn hỗ trợ đệ quy (không có bất kỳ tối ưu hóa nào), được gõ động và phạm vi động (ràng buộc nông). Nó chỉ cung cấp cho người dùng một cấu trúc dữ liệu, ngoài các nguyên tử kiểu dữ liệu cơ bản (nguyên tử, chuỗi, số): danh sách!

Danh sách ngữ nghĩa của Muffin MC (loại) mượn về ngữ nghĩa tập hợp sức mạnh , đó là:

1. Tất cả các hoạt động Muffin MC mang lại một danh sách, có thể trống.
2. Truy cập vào một phần tử danh sách riêng lẻ luôn mang lại một danh sách một giá trị được tạo từ phần tử đó (nghĩ về nó như là một đơn).
3. Danh sách trống là thành phần trung tính trong danh sách hoạt động.

Để giải quyết vấn đề này, những điều sau đây có thể giúp:

• Người ta có thể hình dung một danh sách là thành phần của tập hợp sức mạnh của danh sách có số lượng thẻ lớn nhất.
• Trực quan hóa phần tử của danh sách dưới dạng phần tử của tập hợp sức mạnh của danh sách, là phần tử đơn được tạo từ phần tử đó.
• Hình dung một danh sách trống dưới dạng tập hợp trống; đó là, yếu tố duy nhất của tập hợp sức mạnh của tập hợp trống.

Như vậy, việc truy cập một phần tử danh sách trống sẽ mang lại danh sách trống và không có lỗi! Thật vậy, Muffin MC cố gắng hết sức để ném càng ít lỗi càng tốt bằng cách mở rộng theo cách đó ngữ nghĩa của nhiều hoạt động truyền thống.

Nhiệm vụ 1

#(say "MuffinMC was born in 2015 out of necessity !")

#(...)là lệnh macro MC của MC để áp dụng một hàm trong danh sách đối số không bị loại bỏ, ở đây là hàm tích hợp say, được mượn từ Perl.

#(say 1 2 3 ...) có chức năng giống hệt như map {say $_} (1,2,3,...)

Nhiệm vụ 2

Xác định hàm ascii-art():

=(ascii-art
    '( =(*  x   #(2- $(_1))
        I   I( *($(x) " ") N)
            foo '( #(. #(I $(x))) ))
    #(say ?( #(== $(_1) 1) N "N#(map foo #(.. 1 $(_1)))N" ))
 ))

Ascii-art()Dạng làm việc ngắn nhất (88 byte):

=(f'(=(* x#(2-)I I(*($(x)" ")N)g'(#(.#(I$(x)))))#(say?(#(==$(_1)1)N"N#(map g#(..))N"))))

• =(var val...)là lệnh macro Muffin MC để xác định một biến hoặc gán lại nó.

• $(var)là lệnh macro Muffin MC để truy cập giá trị của biến. Nó tự nhiên chấp nhận các hình thức $(v1 v2 ...)để truy cập nhiều biến cùng một lúc.

• =(* var1 val1 var2 val2 ...)là phần mở rộng của lệnh macro Muffin MC=(...) để xử lý các bài tập song song.

• Các biến _1, _2, ... là phạm vi động (cơ chế liên kết nông) và tự động được đặt để liên kết với các đối số của hàm. Mượn từ Perl5, các biến hệ thống #(số lượng đối số) và @(danh sách các đối số) cũng được đặt tự động.

• Các hàm chỉ đơn giản là các biến bị ràng buộc với bất kỳ số lượng câu lệnh Muffin MC nào .

Giải pháp thú vị này đến từ việc kết hợp hai tính năng tích hợp Muffin MC tự nhiên :

1. Các Muffin MC I(...) lệnh vĩ mô, để xác định đi xe đạp-lặp, sau đó sử dụng với các dạng hàm số #(my-iterator want-number-of-values),

2. Các Muffin MC chuỗi sản phẩm xây dựng, một phần mở rộng của suy biến tự nhiên, trong đó, đưa ra bất kỳ chuỗi "F1 F2 F3...", nơi F i s là một trong hai Muffin MC xâu hoặc Muffin MC lệnh vĩ mô (aka dạng hàm số), sẽ tạo ra nhiều chuỗi như được đưa ra bởi hồng y sản phẩm (F1) x hồng y (F2) x ....

Chẳng hạn, biến xa được đưa ra chứa 2 giá trị, cho biết a và b và y một biến khác chứa 3 giá trị, giả sử, 1 2 3, sau đó việc đánh giá chuỗi "x=$(x) y=$(y))"sẽ tạo ra 6 giá trị khác nhau, cụ thể là theo thứ tự đó:

• "x = ay = 1"
• "x = ay = 2"
• "x = ay = 3"
• "x = by = 1"
• "x = by = 2"
• "x = by = 3"

Đây là một trong những tính năng rất đáng mong đợi của dự án MUTINY được Muffin MC thiết kế cho.

Chạy đi!

#(ascii-art 1)

N


#(ascii-art 3)

N N  
NNN  
N N 


#(map '( #(ascii-art $(_1))) 5 7 9)

N   N
NN  N
N N N
N  NN
N   N

N     N
NN    N
N N   N
N  N  N
N   N N
N    NN
N     N

N       N
NN      N
N N     N
N  N    N
N   N   N
N    N  N
N     N N
N      NN
N       N

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

Thuật toán của chúng tôi dựa trên các nội dung sau:

Gọi cho ascii-art (n), {n = 2p + 1 | p số nguyên, p> = 0}, nghệ thuật để tạo bao gồm n chuỗi gồm n ký tự, trong đó, hai, bên trái và bên phải nhất, được cố định và luôn giống nhau: 'N'. Điều này cho phép giảm vấn đề trong việc chỉ sản xuất các chuỗi giữa. Chẳng hạn, với n = 5, chúng tôi sẽ tạo ra 5 chuỗi giữa sau, mỗi chuỗi được tạo bởi n-2 ký tự (chúng tôi đã thay thế khoảng trắng bằng '_' để hiển thị tốt hơn):

    The 5 strings :
        _ _ _
        N _ _ 
        _ N _
        _ _ N
        _ _ _

    can be seen as resulting from splitting in groups of 3 characters
    the following infinite sequence of 4 characters :


        /---- < _ _ _ N > ----\
       |                       |
        \---------------------/    


    which, once unfolded, yields the infinite ruban : 

        _ _ _ N _ _ _ N _ _ _ N _ _ _ N _ _ _ N _ _ _ N ...
              ^     ^     ^     ^     
        _ _ _ |     |     |     |
              N _ _ |     |     | 
                    _ N _ |     |
                          _ _ N |
                                _ _ _

• Các chuỗi giữa như vậy có thể dễ dàng được tạo ra bằng cách đạp qua chuỗi 4 phần tử ('_' '_' '_' 'N')trong 5 nhóm 3; cho n, đầu vào của hàm, chuỗi như vậy được tạo từ n-2 ký tự '_', theo sau là ký tự 'N'. Đạp xe qua chuỗi này không đòi hỏi gì khác ngoài việc nhúng chuỗi trong Trình lặp tích hợp Muffin MC I(sequence) (một trình vòng lặp xoay vòng mãi mãi trên chuỗi giá trị ban đầu của nó).

• Sau đó, chúng tôi chỉ đơn giản tạo ra các chuỗi giữa, có độ dài n-2, bằng cách yêu cầu trình lặp của chúng tôi cung cấp cho chúng tôi các giá trị n-2 tiếp theo (n - 2 ký tự), được nối với nhau để tạo ra chuỗi giữa dự kiến.

• Chuỗi n giữa được tạo ra bằng cách lặp lại n lần quy trình trên, sử dụng bản đồ để thu thập kết quả n (n chuỗi gồm n-2 ký tự).

• Chúng tôi sử dụng một cấu trúc tích hợp Muffin MC mạnh mẽ khác , cụ thể là sản phẩm chuỗi , để tạo ra n chuỗi cuối cùng : "N#(map...)N".

• Và đó là nó!

  Commented script  
  
  =(ascii-art                    Define the 'ascii-art' variable to hold
                                 the function's definition.
                                 When called, its argument, the actual
                                 value of n, will be bound to the system
                                 variable _1, accessed as $( _1 ).
  
      '(                         '(...) quote macro-command -- protects 
                                 its arguments, here the function 
                                 definition, from being evaluated.
                                 We want to keep it literally for further evaluation.
  
         =(*                     =(*...) // assignment macro-command.
                                 Similar to the Lisp (let (...)...),
                                 not the let* !
  
             x #(2- $(_1))       Define the variable x to hold the value 
                                 n-2.   
  
             I I(                Define I to be an iterator over the 
                                 the x+1 characters sequence :
                  *( $(x) " ")   . x white-space characters
                  N              . 1 'N' character (here the atom N)
               )
  
             foo '(              Define the variable foo as a function 
                    #(.          to catenate ( #(. s1...) )
                       #(I $(x)) the iterator's next x elements.
                     )            
             )
         )                       End of =(*...
  
      #(say                      Print each element of:
         ?(                      If
            #(== $(_1) 1)        n equals 1
    N                    the atom N,
    "N#(map foo #(.. 1 $(_1)))N" else the n strings as a string-product 
                                 resulting from foo-computing the  
         )                       n middle-strings.
       )
   ))
  

Nhiệm vụ 3

Xác định hàm gcd():

=(gcd '( ?( #(== $(_2) 0)
        $(_1)
            #(self $(_2) #(mod $(_1) $(_2)))) ))

gcd()'s thực hình thức ngắn nhất (37 byte - 2bytes đạt được nhờ vào Rodolvertice)

=(g'(?(#(z$(_2))$(_1)#(g$(_2)#(mod)))))

Chạy đi!

#(gcd 225 81)

mang lại 9.

Đó là nó.

Cảm ơn bạn vì trò chơi hay, và có thể vì sự quan tâm của bạn. Ngôn ngữ có sẵn cho bất kỳ ai muốn chơi cùng, sử dụng hoặc thậm chí mở rộng nó. Chỉ cần yêu cầu và tôi sẽ vui mừng gửi nó vào.

Chúc mừng

Franck

Tái bút Triển khai hiện tại của Muffin MC là trong Perl5. Mã nguồn là khoảng 2000 dòng Perl hiện đại, bao gồm các bình luận, và nó đi kèm với một bộ kiểm tra không hồi quy, rất phù hợp để tìm hiểu các cấu trúc và ngữ nghĩa của Muffin MC thực hành .