ในความท้าทายนี้ผู้ใช้จะได้ทำภารกิจการเขียนโค้ดอย่างง่าย ๆ สามอย่างในภาษาการเขียนโปรแกรมที่ได้รับอนุญาตให้เก่าขึ้นเรื่อย ๆ

คำตอบแรกต้องใช้ภาษาการเขียนโปรแกรมที่เกิดขึ้นในปี 2558 เมื่อมีอย่างน้อยหนึ่งคำตอบจากภาษา 2015 คำตอบอาจใช้ภาษาการเขียนโปรแกรมที่ทำในปี 2014 ในทำนองเดียวกันคำตอบที่ใช้ภาษาจาก 2013 จะไม่ได้รับอนุญาต จนกว่าจะมีคำตอบอย่างน้อยหนึ่งคำตอบ 2014

โดยทั่วไปการใช้ภาษาการเขียนโปรแกรมจากปี Y ไม่ได้รับอนุญาตจนกว่าจะมีการส่งคำตอบโดยใช้ภาษาตั้งแต่ปี Y + 1 ข้อยกเว้นเพียงอย่างเดียวคือ Y = 2015

หาปีภาษาของคุณ

ในการตอบคำถามนี้คุณต้องรู้ว่าปีที่ภาษาการเขียนโปรแกรมของคุณ "ถูกสร้างขึ้น" แน่นอนว่าเป็นคำที่เป็นอัตวิสัย บางภาษาได้รับการพัฒนาในช่วงเวลาหลายปีและหลายภาษายังคงได้รับการอัพเกรดทุกปี ให้ปีที่ภาษา "ทำใน" เป็นปีแรกที่มีการใช้ภาษานั้นในที่สาธารณะ

ตัวอย่างเช่นPythonถูก "สร้างขึ้นในปี 1991 " แม้ว่าการพัฒนาจะเริ่มต้นตั้งแต่ปี 1989 และรุ่น 1.0 ยังไม่ได้เปิดตัวจนกว่าจะถึงปี 1994

หากปีนี้ยังคงเป็นอัตวิสัยเพียงใช้สามัญสำนึกของคุณเพื่อเลือกปีที่เหมาะสมที่สุด อย่าจมดิ่งลงในความไม่เห็นด้วยเล็กน้อยเกี่ยวกับตัวเลือกปี โปรดระบุลิงก์ไปยังแหล่งข้อมูลที่ระบุว่าเมื่อใดที่ภาษาของคุณถูกสร้างขึ้น

รุ่นหรือมาตรฐานที่แตกต่างกันของภาษาการเขียนโปรแกรม (เช่น Python 1, 2, 3) จะนับเป็นภาษาเดียวกันกับปีแรกเริ่มเดียวกัน

ดังนั้นหากปีภาษาของคุณคือปี 2558 คุณจะสามารถส่งคำตอบได้ก็ต่อเมื่อมีการส่งคำตอบซึ่งปีของภาษานั้นเป็นปีก่อนหน้าคุณ

หากคำตอบที่ถูกต้องในปีเดียวกับที่คุณมีอยู่แล้วคุณอาจตอบ ไม่สำคัญว่าภาษาของคุณจะพัฒนาเร็วกว่าหรือช้ากว่านี้ในปี

งาน

คุณต้องทำภารกิจ 1 ถึง 3 ให้เสร็จสิ้นภารกิจ 0 เป็นทางเลือก

งานเหล่านี้ได้รับการคัดเลือกมากขึ้นหรือน้อยลงเพื่อให้สอดคล้องกับลักษณะสำคัญสามประการของการโปรแกรมมิง: การให้เอาต์พุต (งาน 1), การวนซ้ำ (งาน 2) และการเรียกซ้ำ (งาน 3)

ภารกิจ 0 - ประวัติภาษา (ไม่บังคับ)

เขียนอย่างน้อยหนึ่งย่อหน้าเพื่ออธิบายประวัติของภาษาการเขียนโปรแกรมที่คุณเลือก: ใครเป็นผู้พัฒนามันทำไมอย่างไร ฯลฯ ได้รับการสนับสนุนเป็นพิเศษหากคุณอยู่ใกล้ ๆ เมื่อภาษานั้นเข้ามามีส่วนร่วมและอาจมีส่วนร่วมในการพัฒนา รู้สึกอิสระที่จะเชื่อมโยงเกร็ดเล็กเกร็ดน้อยส่วนตัวเกี่ยวกับผลกระทบของภาษาที่มีต่อคุณหรืองานของคุณหรืออะไรทำนองนั้น

หากคุณยังเด็กเกินไปที่จะรู้ประวัติความเป็นมาของภาษาของคุณโดยไม่ต้องค้นคว้ามากนักให้ทิ้งโน้ตไปยังผู้ใช้เก่าที่ระบุว่าพวกเขาสามารถแก้ไขโพสต์ของคุณและเพิ่มในประวัติมือแรกได้

ภารกิจที่ 1 - "สวัสดีโลก!" ตัวแปร

เขียนโปรแกรมที่พิมพ์

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

ไปยังพื้นที่แสดงผลมาตรฐานของภาษาของคุณ (stdout สำหรับภาษาล่าสุด)

ตัวอย่างเช่นถ้าภาษาเป็น Python เอาต์พุตจะเป็น:

Python was made in 1991!

ภารกิจที่ 2 - ASCII Art N

เขียนโปรแกรมที่ช่วยให้ผู้ใช้ป้อนในจำนวนเต็มบวกคี่ (คุณอาจคิดการป้อนข้อมูลที่ถูกต้องอยู่เสมอ) และพิมพ์ออกจดหมายศิลปะ ASCII N Nทำโดยใช้ตัวอักษรที่

หากอินพุตเป็น 1 เอาต์พุตจะเป็น:

N

หากอินพุตเป็น 3 เอาต์พุตจะเป็น:

N N
NNN
N N

หากอินพุตเป็น 5 เอาต์พุตจะเป็น:

N   N
NN  N
N N N
N  NN
N   N

หากอินพุตเป็น 7 เอาต์พุตจะเป็น:

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

รูปแบบยังคงดำเนินต่อไปเช่นนี้ ผลลัพธ์อาจมีช่องว่างต่อท้าย

งาน 3 - GCD

เขียนโปรแกรมที่ช่วยให้ผู้ใช้ป้อนในจำนวนเต็มบวก (คุณอาจคิดการป้อนข้อมูลที่ถูกต้องอยู่เสมอ) และพิมพ์ของพวกเขาตัวหารร่วมมาก นี่ถูกกำหนดให้เป็นจำนวนเต็มบวกที่ใหญ่ที่สุดที่หารทั้งสองตัวเลขโดยไม่เหลือส่วนที่เหลือ มันสามารถคำนวณได้อย่างง่ายดายโดยใช้ขั้นตอนวิธี Euclidean

ตัวอย่าง:

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

คุณอาจใช้ฟังก์ชันที่มีอยู่แล้วภายใน แต่ลองค้นหาว่ามันมีอยู่ในภาษารุ่นแรกของคุณหรือไม่ ถ้าไม่ลองใช้มัน

กฎระเบียบ

• คุณอาจตอบได้หลายครั้ง แต่คำตอบใหม่แต่ละคำต้องใช้ภาษาที่ทำอย่างน้อย 5 ปีก่อนภาษานั้นในคำตอบสุดท้ายของคุณ ดังนั้นหากคุณตอบด้วยภาษาปี 2015 คุณจะไม่สามารถตอบได้อีกจนกว่าจะมีการอนุญาตให้ใช้ภาษาในปี 2010 หากคุณเริ่มต้นด้วยคำตอบของปี 2010 คุณจะไม่สามารถตอบคำตอบที่สองของคุณได้เพราะปี 2015 ไม่ใช่ก่อนปี 2010
• หากเป็นไปได้ให้เขียนรหัสของคุณเพื่อให้ทำงานได้ในภาษาแรกของคุณ (หรือเป็นรุ่นเก่าที่สุดเท่าที่จะเป็นไปได้) (นี่ไม่ใช่ข้อกำหนดเนื่องจากการค้นหาตัวแปลภาษา / ตัวแปลภาษาเก่าสำหรับบางภาษาอาจเป็นเรื่องยาก)
• หลีกเลี่ยงการโพสต์ภาษาที่โพสต์ไว้แล้วยกเว้นว่าคำตอบที่โพสต์นั้นมีข้อผิดพลาดที่สำคัญหรือคุณมีวิธีการทำงานที่แตกต่างกันมาก
• การตีกอล์ฟรหัสของคุณนั้นใช้ได้ แต่ไม่จำเป็น
• บรรทัดใหม่ต่อท้ายในเอาต์พุตของโปรแกรมใด ๆ นั้นใช้ได้
• สำหรับภารกิจ 2 และ 3 ค่าอินพุตทั้งหมดต่ำกว่าค่าสูงสุดที่เหมาะสมเช่น 2 ¹⁶ควรใช้งานได้ (256 อย่างน้อยที่สุด)
• ภาษาของคุณต้องมีอยู่ก่อนที่จะโพสต์คำถามนี้
• ภาษาการเขียนโปรแกรมที่เก่ามากอาจมีรูปแบบการป้อนข้อมูลและผลลัพธ์ที่แตกต่างจากที่เราคิดในปัจจุบัน นี่เป็นเรื่องปกติ ทำงานให้ดีที่สุดเท่าที่จะทำได้ในบริบทของภาษาของคุณ

เกณฑ์การให้คะแนน

คะแนนที่คุณส่งคือ:

upvotes - downvotes + (2015 - languageYear) / 2 

ดังนั้นจะมีการเพิ่มการนับคะแนน 0.5 ในทุก ๆ ปีก่อนปี 2558 ซึ่งเป็นข้อได้เปรียบสำหรับภาษาที่เก่ากว่า การส่งที่มีคะแนนสูงสุดจะเป็นผู้ชนะ

รายการคำตอบ

สแต็คส่วนย่อยด้านล่างแสดงคำตอบที่ถูกต้องทั้งหมดตามปีภาษาของพวกเขา

คุณต้องเริ่มโพสต์ด้วยบรรทัดMarkdownนี้เพื่อให้แน่ใจว่ารายการนั้นถูกต้อง:

#[year] - [language name]

ตัวอย่างเช่น:

#1991 - Python

ชื่อภาษาอาจอยู่ในลิงค์ (จะเป็นลิงค์เดียวกันในรายการคำตอบ):

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

คำตอบที่ไม่เป็นไปตามรูปแบบนี้หรือมีปีที่ยังไม่ได้รับอนุญาตหรือมาจากผู้ใช้ที่ตอบแล้วในช่วง 5 ปีที่ผ่านมาถูกทำเครื่องหมายว่าไม่ถูกต้อง

<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 - Dogescript

Dogescriptเป็นภาษาที่สร้างขึ้นในปี 2013 โดย Zach Bruggeman มันไม่มีอะไรมากไปกว่าการใช้ไวยากรณ์แทน Javascript เพื่อให้อ่านได้เหมือนกับการสะสมภายในของ Shiba Inus

สวัสดี doge

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

ศิลปะ 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 - จอประสาทตา

Retina เป็นภาษาการเขียนโปรแกรมตาม regex ซึ่งฉันเขียนเพื่อให้สามารถแข่งขันในความท้าทาย PPCG ด้วยคำตอบเฉพาะ regex เท่านั้นโดยไม่ต้องมีค่าใช้จ่ายที่ไม่จำเป็นในการเรียก regex ในภาษาโฮสต์บางภาษา Retina เป็นทัวริงที่สมบูรณ์ เพื่อพิสูจน์ว่าผมได้ใช้ระบบ 2 แท็กแก้เช่นเดียวกับกฎข้อที่ 110 มันถูกเขียนใน C # ดังนั้นจึงรองรับทั้ง. NET รส (โดยค่าเริ่มต้น) และ ECMAScript รส (ผ่านธง)

จอประสาทตาสามารถทำงานได้ในหลายโหมด แต่โหมดที่เกี่ยวข้องที่สุดสำหรับการคำนวณ (และโหมดทัวริงสมบูรณ์) คือโหมดแทนที่ ในโหมดแทนที่คุณจะให้ Retina เป็นจำนวนไฟล์ต้นฉบับ สิ่งเหล่านี้จะถูกจับคู่แล้วคู่แรกของแต่ละคู่จะเป็น regex และคู่ที่สองจะมาแทนที่ สิ่งเหล่านี้จะถูกดำเนินการตามลำดับจัดการกับขั้นตอนการป้อนข้อมูลทีละขั้นตอน regex ยังสามารถนำหน้าด้วยการกำหนดค่า (คั่นด้วย`) ตัวเลือกที่สำคัญที่สุด (ซึ่งทำให้การทำให้ทัวริงสมบูรณ์) คือ+ซึ่งทำให้ Retina ใช้การแทนที่แบบวนซ้ำจนกว่าผลลัพธ์จะหยุดการเปลี่ยนแปลง ในตัวอย่างต่อไปนี้ฉันใช้;เช่นกันซึ่งจะหยุดเอาต์พุตในขั้นตอนระดับกลาง

ในแต่ละการส่งต่อไปนี้แต่ละบรรทัดจะไปในไฟล์ต้นฉบับที่แยกต่างหาก (หรือคุณสามารถใช้ใหม่-sตัวเลือกและวางสายทั้งหมดเป็นไฟล์เดียว.) ไฟล์ที่ว่างเปล่า / <empty>สายจะแสดงเป็น ไฟล์ / <space>บรรทัดที่มีพื้นที่เดียวจะแสดงเป็น

คำอธิบายนั้นค่อนข้างยาวดังนั้นฉันจึงย้ายพวกเขาไปที่ท้ายโพสต์

โปรแกรม

"สวัสดีชาวโลก!" ตัวแปร

<empty>
Retina was made in 2015!

ASCII Art N

นี่ถือว่า STDIN ถูกยกเลิกด้วยการขึ้นบรรทัดใหม่

;`^
#
;+`(\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

สิ่งนี้ต้องการให้ STDIN ไม่ได้ถูกยกเลิกด้วยการขึ้นบรรทัดใหม่

;`\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>

คำอธิบาย

"สวัสดีชาวโลก!" ตัวแปร

นี่เป็นเรื่องเล็กน้อย มันต้องใช้เวลาไม่มีการป้อนข้อมูล (เช่นสตริงที่ว่างเปล่า) Retina was made in 2015!ตรงกับอะไรและแทนที่มันด้วย ท่านสามารถทำให้มันทำงานสำหรับอินพุตโดยพลการโดยแทนที่รูปแบบด้วย[\s\S]*เช่น ที่จะลบล้าง STDIN และแทนที่ทั้งหมดด้วยเอาต์พุต

ASCII Art N

มีขั้นตอนค่อนข้างมาก แนวคิดคือการแปลงอินพุตให้เป็นอันหนึ่งอันเดียวกันสร้างบล็อก N x N ของNs แล้ว "แกะสลัก" สามเหลี่ยมสองรูป เราไปผ่านแต่ละด่าน โปรดจำไว้ว่า;เพียงระงับเอาต์พุตกลาง แต่+ทำให้การแทนที่ถูกนำไปใช้ในการวนซ้ำ

;`^
#

ง่าย: เสริม a #ถึงอินพุต สิ่งนี้จะถูกใช้เป็นเครื่องหมายในการแปลงเป็นเอกภาพ

;+`(\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#

สิ่งนี้จะแปลงหนึ่งหลักเป็นเอก ใช้ตัวเลขที่แปลงแล้ว(\d*)และทำซ้ำ 10 ครั้ง จากนั้นจะใช้ตัวเลขถัดไปและผนวกจำนวนหลักที่เหมาะสม มูลค่าที่แท้จริงของตัวเลขไม่เกี่ยวข้องในขั้นตอนนี้ เมื่อ#ถึงจุดสิ้นสุดของจำนวน regex ไม่ตรงและแปลงเสร็จแล้ว ตัวอย่างเช่นหมายเลข127จะถูกประมวลผลเป็น

#127
1#27
111111111122#7
1111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111227777777#

โดยที่บรรทัดสุดท้ายมีจำนวนอักขระ 127 หลัก

;`#
<empty>
;`\d
N

สองขั้นตอนง่ายๆที่ได้รับการกำจัดที่แล้วแปลงตัวเลขทั้งหมดเพื่อ# Nในตัวอย่างต่อไปนี้ฉันจะใช้อินพุต7เป็นตัวอย่าง ตอนนี้เรามีแล้ว

NNNNNNN

ขั้นต่อไป

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

แทนที่แต่ละรายการNด้วยสตริงทั้งหมด (โปรดจำไว้ว่ามันมีบรรทัดใหม่ต่อท้าย) และยังลบบรรทัดขึ้นบรรทัดใหม่เอง ดังนั้นนี่จะเปลี่ยนแถวเดียวเป็นตารางสี่เหลี่ยม:

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN

ทีนี้สามเหลี่ยมบน อันดับแรกเราจะเริ่มต้นสิ่งต่าง ๆ โดยการเปลี่ยน N ที่มุมขวาล่างลงในช่องว่าง:

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

lookahead Nเพื่อให้แน่ใจว่าเรากำลังปรับเปลี่ยนให้ถูกต้อง สิ่งนี้จะช่วยให้

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNN N
NNNNNNN
NNNNNNN

และตอนนี้

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

คือ regex ที่ตรงกับNที่อยู่เหนือหรือที่มุมซ้ายบนของอักขระเว้นวรรคและแทนที่ด้วยช่องว่าง เนื่องจากการแทนที่ซ้ำแล้วซ้ำอีกนี่คือการเติมน้ำท่วมซึ่งจะเปลี่ยน octant ที่ 3 จากพื้นที่เริ่มต้นไปเป็นช่องว่างเพิ่มเติม:

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

และสุดท้ายเราทำซ้ำสิ่งเดียวกันกับสามเหลี่ยมด้านล่าง แต่เราใช้อักขระที่แตกต่างกันดังนั้นช่องว่างที่มีอยู่แล้วไม่ก่อให้เกิดน้ำท่วมที่ไม่ถูกต้อง:

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

ชุดเมล็ด:

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

แล้วก็

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

ไม่เติมน้ำท่วม

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

และในที่สุดก็

S
<space>

เปลี่ยนสิ่งเหล่านั้นSเป็นช่องว่างและเราเสร็จแล้ว:

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

GCD

GCD ที่ไม่เป็นน้ำหนึ่งใจเดียวกันจริง ๆ แล้วเป็นเรื่องเล็กน้อยกับ regex ส่วนใหญ่ประกอบด้วยทศนิยมเพื่อแปลงและแปลงเป็นทศนิยม สิ่งนี้สามารถทำได้มากกว่าขนาดกะทัดรัด แต่นี่ไม่ใช่รหัสกอล์ฟดังนั้น ...

;`\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

ขั้นตอนเหล่านี้เป็นหลักเหมือนกับข้างต้นยกเว้นว่ามีการแปลงหมายเลขอินพุตทั้งสองและผลลัพธ์ใช้1s แทนNs (ไม่ใช่ที่สำคัญ) ดังนั้นถ้าอินพุทก็18 24จะสร้าง

111111111111111111 111111111111111111111111

ตอนนี้

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

เป็นการคำนวณ GCD ทั้งหมด เราจับคู่ตัวหารร่วมด้วยการจับจำนวน1s แล้วใช้ backreferences เพื่อให้แน่ใจว่าสามารถเขียนตัวเลขทั้งสองได้โดยการทำซ้ำสตริงนั้น (และไม่มีอะไรอื่น) เนื่องจากการย้อนรอยทำงานในเอ็นจิน regex (นั่น.+คือโลภ) สิ่งนี้จะทำให้ตัวหารทั่วไปที่ยิ่งใหญ่ที่สุดโดยอัตโนมัติ เนื่องจากการแข่งขันครอบคลุมสายทั้งหมดเราเพียงแค่เขียนกลุ่มจับภาพแรกเพื่อรับ GCD ของเรา

ในที่สุดการแปลงทศนิยมให้เป็นทศนิยม ...

;`$
#:0123456789

ผนวกเครื่องหมาย#, ตัวคั่น:และตัวเลขทั้งหมดไปยังสตริง สิ่งนี้จำเป็นเพราะคุณไม่สามารถสร้างตัวละครใหม่อย่างมีเงื่อนไขในการแทนที่ regex หากคุณต้องการการแทนที่แบบมีเงื่อนไขคุณต้องดึงอักขระจากสตริงเองดังนั้นเราจึงวางมันไว้ที่นั่น

;+`^(?=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

นี่คือสิ่งที่ตรงกันข้ามกับการขยายตัวของเอกนารีก่อนหน้า เราพบตัวคูณที่ใหญ่ที่สุดของ 10 ที่พอดีกับสตริงปัจจุบัน จากนั้นเราเลือกตัวเลขถัดไปตามส่วนที่เหลือแล้วหารด้วย 10 ด้วยการย้ายเครื่องหมายผ่านตัวเลข

#|:.*
<empty>

และสุดท้ายเป็นเพียงขั้นตอนการทำความสะอาดเพื่อกำจัดเครื่องหมายตัวคั่นและตัวช่วยหลัก

2013 - ถ่ายเอง!

สแนป! เป็นภาษาที่ใช้ในScratchซึ่งผลิตขึ้นที่ Berkeley University เป็นการอัปเกรดเป็น Scratch ซึ่งมีข้อมูลชั้นหนึ่งและบล็อกที่กำหนดเอง (ฟังก์ชั่น) เช่นเดียวกับ Scratch มันไม่ได้เป็นข้อความ แต่จะทำโดย "บล็อก" แบบภาพที่รวมเข้าด้วยกัน

สแนป! เขียนใน JavaScript เป็นผู้สืบทอดของ BYOB ซึ่งเขียนใน Squeak Smalltalk สแนป! ได้รับเบต้าออกสำหรับการบริโภคของประชาชนในเดือนมีนาคมปี 2013

สแนป! ไม่ใช่ภาษาลึกลับ มันถูกใช้เป็นภาษาการเขียนโปรแกรมสำหรับหลักสูตรBeauty and Joy of Computing (BJC) AP CS ที่ Berkeley และอื่น ๆ

ฉันช่วยด้วยการทดสอบและสิ่งต่าง ๆ

ชุด "Hello World"

ศิลปะ ASCII "N"

นี่ใช้ stdlib สำหรับบล็อกบางส่วน

พริตตี้ลูปพื้นฐานที่นี่ รับอินพุต จากนั้นเราก็รวมมันเข้าด้วยกันแล้วบอกว่ามัน (ผลสำหรับ n = 5):

ฉันเอาเสรีภาพมาที่นี่เพื่อใช้ 2 ช่องว่างแทน 1 เพราะ Snap! ไม่ได้พูดอะไรในอวกาศ

GCD

อัลกอริทึมแบบยุคลิดไม่เร็วมาก แต่ใช้งานได้และค่อนข้างง่าย (ขออภัยฉันพิมพ์ผิดในชื่อบล็อกตอนนี้ฉันปิดแท็บโดยไม่บันทึกมันจะต้องอยู่ต่อไป)

นิยามฟังก์ชันนี้จะสร้างบล็อกนี้:

2550 - LOLCODE

ประวัติภาษา

LOLCODE ถูกสร้างขึ้นในปี 2550 โดย Adam Lindsay นักวิจัยที่ Lancaster University ไวยากรณ์ของมันจะขึ้นอยู่กับ lolcats memes popularized โดย Cheezburger, Inc.

"สวัสดีชาวโลก!" ตัวแปร

HAI
VISIBLE "LOLCODE wuz maed in 2007!"
KTHXBYE

ASCII Art N

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

ค่าที่อ่านเป็นสตริง (เส้นด้าย) จาก stdin GIMMEHใช้ สามารถแปลงเป็นตัวเลข (NUMBRs) โดยการคูณด้วย 1

ค่าจะถูกพิมพ์ไป stdout VISIBLEใช้ โดยค่าเริ่มต้นจะมีการเพิ่มบรรทัดใหม่ แต่สามารถระงับได้ด้วยการเพิ่มเครื่องหมายอัศเจรีย์

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 ทำการเชื่อมต่อสายอักขระ

1982 - PostScript

PostScript เป็นภาษาสำหรับสร้างกราฟิกแบบเวกเตอร์และการพิมพ์

Adobe ก่อตั้งขึ้นในปี 1982 และผลิตภัณฑ์แรกของพวกเขาคือ PostScript ภาษาที่ใช้ในเครื่องพิมพ์: เครื่องพิมพ์ตีความคำสั่งเพื่อสร้างภาพแรสเตอร์ซึ่งจะถูกพิมพ์ลงบนหน้ากระดาษ มันเป็นองค์ประกอบทั่วไปของเครื่องพิมพ์เลเซอร์ในทศวรรษ 1990 แต่เห็นได้ชัดว่ามันค่อนข้างเข้มข้นของซีพียูในเครื่องพิมพ์และเมื่อโปรเซสเซอร์ของคอมพิวเตอร์ทรงพลังมากขึ้นมันก็สมเหตุสมผลที่จะทำการแรสเตอร์บนคอมพิวเตอร์มากกว่าเครื่องพิมพ์ PostScript ส่วนใหญ่หายไปจากเครื่องพิมพ์ผู้บริโภคแม้ว่าจะยังคงมีอยู่ในเครื่องพิมพ์ระดับสูงจำนวนมาก

มาตรฐานที่แทนที่ PostScript เป็นรูปแบบที่รู้จักกันน้อยที่เรียกว่า PDF

PostScript ล้าสมัยไปตามเวลาที่ฉันเริ่มเขียนโปรแกรม แต่ฉันเรียนรู้เล็กน้อยในขณะที่ฉันอยู่ในมหาวิทยาลัยเป็นอีกวิธีในการสร้างเอกสารสำหรับ TeX มันค่อนข้างแตกต่างจากภาษาการเขียนโปรแกรมอื่น ๆ ที่ฉันเคยใช้ (สัญกรณ์ย้อนกลับมัดสแต็กพิมพ์ไปยังหน้าแทนที่จะเป็นคอนโซล) แต่มันก็ดีที่จะปัดฝุ่นภาษาเก่านี้เพื่อความสนุก

เนื่องจาก PostScript เป็นภาษาการพิมพ์จึงมีความเหมาะสมที่จะใช้เพื่อพิมพ์บางอย่างจากนั้นส่งเอาต์พุตไปยังคอนโซล

ภารกิจที่ 1

/Courier findfont
12 scalefont
setfont
newpath

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

สองสามบรรทัดแรกตั้งค่าผืนผ้าใบเพื่อวาด จากนั้นmovetoคำสั่งจะบอกให้ PS วาดที่ตำแหน่งเฉพาะและshowพิมพ์สตริงไปยังหน้า โปรดทราบว่าเครื่องหมายวงเล็บทำเครื่องหมายสตริงใน PostScript ไม่ใช่เครื่องหมายคำพูด

ภารกิจที่ 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

ฉันเขียนฟังก์ชันสำหรับการวาด“ ASCII art” N แต่ไม่มีวิธีใดที่ฟังก์ชัน PostScript จะโต้แย้ง แต่คุณดันอาร์กิวเมนต์ของคุณไปที่สแต็กจากนั้นลบออก นั่นคือ/x exch defเส้น

ตัวอย่าง: 8 9 2สมมติว่าสแต็คเป็น ครั้งแรกที่เราผลักดันชื่อไปยังกองเพื่อให้สแต็คเป็น/x ประกอบการแลกเปลี่ยนค่าทั้งสองกองดังนั้นตอนนี้สแต็คเป็น แล้วปรากฏด้านบนสองค่าสแต็คและกำหนดให้มีค่า สแต็คอยู่ในขณะนี้8 9 2 /xexch8 9 /x 2def/x28 9

เมื่อฉันเริ่มใช้ PostScript ฉันพบว่ามันสับสนเล็กน้อย ฉันอ่านเกี่ยวกับสแต็คเป็นแนวคิดทางทฤษฎี แต่นี่เป็นครั้งแรกที่ฉันใช้มันในทางปฏิบัติ

ส่วนที่เหลือของฟังก์ชั่นคือรหัสการวาดภาพ: เริ่มต้นที่มุมขวาล่างเติมเป็นแถวในแต่ละครั้งตั้งแต่ซ้ายไปขวาจนถึงเส้นทแยงมุม

ภารกิจที่ 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

อีกครั้งฉันใช้รูปแบบของอัลกอริทึมของ Euclid แต่ฉันลืมไปแล้วว่า PostScript มีโอเปอเรเตอร์ในตัวโมดูโลดังนั้นฉันจึงต้องเขียนเอง สิ่งนี้กลายเป็นเครื่องเตือนความจำที่มีประโยชน์เกี่ยวกับข้อ จำกัด ของการเขียนโปรแกรมแบบกองซ้อน การใช้งานครั้งแรกของฉันmoduloขึ้นอยู่กับการสอบถามซ้ำ:

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

ซึ่งใช้ได้จนกว่าคุณจะพยายามรันสิ่งนี้เมื่อxมีขนาดใหญ่และyเล็ก (เช่น 5689 และ 2) คุณสามารถมีองค์ประกอบได้มากถึง 250 รายการบนสแต็กเท่านั้นดังนั้นฉันจึงผ่านขีด จำกัด สแต็กได้ดี อุ่ย ฉันต้องกลับไปที่กระดานวาดภาพในอันนั้น

รหัส GCD นั้นค่อนข้างง่าย แต่ฟังก์ชั่นไม่สามารถรับอาร์กิวเมนต์ได้ดังนั้นจึงไม่มีค่าส่งคืน แต่คุณต้องผลักดันผลลัพธ์ไปยังสแต็กโดยที่มีคนอื่นสามารถนำออกมาใหม่ในภายหลัง นั่นคือสิ่งที่aและb a gcdบรรทัดทำ: เมื่อพวกเขาประเมินเสร็จแล้วพวกเขาดันค่าลงในสแต็ก

หากคุณใส่รหัสทั้งหมดลงในเอกสารแล้วพิมพ์ออกมานี่เป็นรูปแบบของผลลัพธ์:

2009 - > <>

ได้รับแรงบันดาลใจจาก Befunge> <> (Fish) เป็นภาษา 2D ที่อิงกับสแต็กที่เป็นความลับกล่าวคือการไหลของโปรแกรมสามารถขึ้นลงซ้ายหรือขวา เวอร์ชันเริ่มต้นของ> <> จุดเด่นหลายเธรดที่[และ]สร้างและสิ้นสุดเธรด แต่ด้วยเหตุผลง่าย ๆ คำแนะนำเหล่านี้ถูกเปลี่ยนเป็นการสร้างและลบสแต็คใหม่ตามลำดับ

ล่ามอย่างเป็นทางการปัจจุบัน> <> สามารถพบได้ที่นี่ น่าเสียดายที่ลิงก์ไปยังล่ามเก่าบน Esolang wiki นั้นใช้งานไม่ได้

"สวัสดีชาวโลก!" ตัวแปร

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

โปรดสังเกตว่าการเขียนสตริงนั้นย้อนหลัง -> <> ในทางเทคนิคไม่มีสตริงโดยที่ชนิดข้อมูลเพียงอย่างเดียวคือการผสมระหว่าง char, int และ float "สลับสตริงแยกผลักดันตัวละครแต่ละตัวบนสแต็คจนปิด"จะพบ

ในช่วงครึ่งหลังของรหัสที่แล้วผลักดันให้ความยาวของสแต็คl, ตรวจสอบว่ามันเป็นศูนย์และถ้าเป็นเช่นสิ้นสุดโปรแกรม?! ;ไม่เช่นนั้นตัวชี้คำสั่งจะดำเนินต่อไปให้ส่งสัญญาณด้านบนของสแต็กด้วยoก่อนดำเนินการbb+0.ซึ่งเทเลพอร์ตตัวชี้ไปยังตำแหน่ง(22, 0)ก่อนหน้านั้นจะlสร้างลูป

ASCII Art N

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

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

   \                                                         <   /

ด้วยระยะห่างเพื่อความชัดเจน คุณสามารถลองใช้งานได้ที่ล่ามออนไลน์ใหม่ที่นี่และดูตัวชี้คำแนะนำไปรอบ ๆ - อย่าลืมป้อนตัวเลขในกล่องข้อความ "เริ่มต้นสแต็ค" หากคุณใช้งานผ่านล่ามภาษาไพ ธ อนให้ใช้การ-vตั้งค่าสถานะเพื่อเริ่มต้นสแต็กเช่น

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

สำหรับโปรแกรมนี้เราใส่ข้อมูลnในการลงทะเบียนด้วย&และกด 0 ซึ่งเราจะเรียกว่าi"การทำซ้ำ" ส่วนที่เหลือของโปรแกรมคือวงวนยักษ์ซึ่งมีลักษณะดังนี้:

:&:&:*=?;          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

จากนั้นเราวนซ้ำตั้งแต่ต้น

ลูกศร^>v<เปลี่ยนทิศทางของการไหลของโปรแกรมและกระจก/\สะท้อนให้เห็นถึงทิศทางของการไหลของโปรแกรม

GCD

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

นี่คือตัวอย่างของโปรแกรม golfed> <> ที่อาจมีหน้าตา คุณสามารถลองอีกครั้งในล่ามออนไลน์ (ป้อนสองค่าที่คั่นด้วยเครื่องหมายจุลภาคในกล่อง "Initial stack" เป็นต้น111, 87) หรือใช้การ-vตั้งค่าสถานะของ Python interpreter เช่น

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

โปรแกรมนี้ใช้อัลกอริทึมแบบยุคลิด นี่คือ GIF ที่ฉันเตรียมไว้ก่อนหน้านี้:

โปรดทราบว่า> <> นั้นเป็น toroidal ดังนั้นเมื่อvมีการดำเนินการคำสั่งด้านล่างซ้ายตัวชี้คำสั่งจะลดลงล้อมรอบและปรากฏขึ้นอีกครั้งที่ด้านบน

แก้ไข: การทำให้โค้ดทำงานจากขวาไปซ้ายทั้งหมด @randomra สามารถจัดการได้ด้วยการโกนสามไบต์

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

คิดว่าฉันเล่นกอล์ฟไม่พอ :)

2012 - องค์ประกอบ

นี่เป็นภาษาที่ฉันคิดค้นในต้นปี 2012 เพื่อเป็นภาษากอล์ฟที่เรียบง่าย จากนี้ฉันหมายถึงว่ามีตัวดำเนินการมากไปน้อยหรือไม่มีเลย ผู้ประกอบการยังง่ายกว่าและน้อยกว่าจำนวนภาษากอล์ฟที่ทันสมัยที่สุด

คุณสมบัติที่น่าสนใจที่สุดของภาษานี้คือโครงสร้างข้อมูล มีสองกองและแฮที่ใช้ในการเก็บข้อมูล

m-stack เป็นสแต็กหลักที่มีการคำนวณและการดำเนินการอื่น ๆ ส่วนใหญ่เกิดขึ้น เมื่อมีการป้อนหรือพิมพ์ข้อมูลนี่คือที่ที่จะไปหรือดึงจาก

c-stack คือสแต็กควบคุม นี่คือที่ที่เลขคณิตแบบบูลเกิดขึ้น ค่าสูงสุดของ c-stack ถูกใช้โดย If และ while ลูปเป็นเงื่อนไข

แฮชเป็นที่เก็บตัวแปร ;และ~การจัดเก็บและดึงข้อมูลจากกัญชาตามลำดับ

องค์ประกอบเป็นภาษาที่พิมพ์อย่างอ่อนมาก มันใช้ความสามารถของ Perl ในการตีความตัวเลขอย่างอิสระเป็นสตริงและในทางกลับกัน

ในขณะที่ฉันอยู่ที่นี่ฉันอาจรวมเอกสารทั้งหมดสำหรับภาษาด้วย คุณสามารถค้นหาเดิม 2,012 ล่ามเขียนใน Perl ขวาที่นี่ ปรับปรุง: ฉันได้สร้างรุ่นที่สามารถใช้งานได้มากขึ้นซึ่งคุณสามารถหาที่เหมาะสมที่นี่

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 \

งาน 1 - พิมพ์ข้อความ

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

อีกส่วนหนึ่งที่น่าอึดอัดใจของภาษาคือการขาดตัวคั่นสตริงซึ่งเป็นเหตุผลที่จำเป็นต้องใช้อักขระยกเว้นในสตริงนี้ `ที่สิ้นสุดพิมพ์สตริง

ภารกิจที่ 2 - ASCII Art N

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

ที่นี่คุณจะได้เห็นการจัดการกองซ้อน เพื่อให้คำอธิบายที่ง่ายขึ้นเล็กน้อยเป็นรูปแบบที่ผมจะเข้ามาแทนที่การขึ้นบรรทัดใหม่ด้วยและพื้นที่ที่มีLS

_+'[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

หลังจากเล่นกอล์ฟกับคำตอบนี้ฉันพบวิธีแก้ปัญหา 39 ไบต์แม้ว่ามันจะซับซ้อนกว่ามาก

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

งาน 3 - GCD

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

นี่เป็นวิธีการกองซ้อน

__                 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 ได้รับการพัฒนาในปี 2012 โดย Jeff Bezanson, Stefan Karpinski และ Viral Shah ในขณะที่ Jeff เป็นนักเรียนที่สถาบันเทคโนโลยี Massachussets (MIT) ได้รับคำแนะนำจากศาสตราจารย์ Alan Edelman พวกเขาได้รับแรงบันดาลใจจากความต้องการภาษาโปรแกรมที่เป็นโอเพ่นซอร์สรวดเร็วและมีพลวัต ผลิตภัณฑ์นี้คือ Julia แนวทางใหม่ในการคำนวณทางวิทยาศาสตร์ที่มีประสิทธิภาพสูง

"สวัสดีชาวโลก!" ตัวแปร

println("Julia was made in 2012!")

การพิมพ์ไปยัง STDOUT ใน Julia นั้นค่อนข้างง่าย!

ASCII Art N

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

รหัสนี้ถูกเยื้องสำหรับการอ่านได้ แต่ Julia ไม่มีข้อ จำกัด เกี่ยวกับช่องว่าง

GCD

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

สิ่งสุดท้ายที่ระบุไว้ในฟังก์ชั่นจะถูกส่งกลับโดยปริยาย

1988 - Mathematica

หรือฉันควรจะเรียกมันว่าWolfram Language ?

ภารกิจ 0

ผู้สร้าง Mathematica คือ Stephen Wolfram ผู้ก่อตั้งและ CEO ของ Wolfram Research ก่อนที่จะพัฒนา Mathematica เขาเป็นนักฟิสิกส์ มีเป็นจำนวนมากของการคำนวณเกี่ยวกับพีชคณิตในฟิสิกส์เพื่อให้เขากลายเป็นผู้ใช้Macsyma

Wolfram ได้รับปริญญาเอกในปี 1979 เมื่อเขาอายุ 20 ปีเขาคิดว่าเขาต้องการ CAS ที่ดีกว่า Macsyma ในการทำฟิสิกส์ดังนั้นเขาจึงเริ่มเขียนSMP ("โปรแกรมจัดการสัญลักษณ์") รุ่นแรกของ SMP เปิดตัวในปี 1981 SMP เป็นรุ่นก่อนของ Mathematica แม้ว่ามันจะมีอิทธิพลอย่างลึกซึ้งต่อ Mathematica แต่ก็ไม่มีการใช้รหัสใด ๆ สำหรับ Mathematica

ในปี 1986 Wolfram ตัดสินใจที่จะเขียน "ระบบการคำนวณขั้นสุดท้าย" เขาเริ่มเขียนโค้ดในปี 1986 และก่อตั้ง Wolfram Research ในปี 1987 ในที่สุด Mathematica 1.0 ก็ได้เปิดตัวเมื่อวันที่ 23 มิถุนายน 1988

ฉันไม่พบ Mathematica 1.0 ในความเป็นจริง Mathematica 1.0 ไม่มีทั้ง Windows และ Linux แต่ฉันพบ Mathematica 2.0 บนเว็บไซต์จีน มันยังคงสามารถเรียกใช้บน Windows XP

ภารกิจที่ 1

Print["Mathematica was made in 1988!"]

หรือเพียงแค่:

"Mathematica was made in 1988!"

ภารกิจที่ 2

ใน Mathematica วันนี้เราสามารถเขียน:

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

เช่นเดียวกับJuliaและRนี่คือวิธีแก้ปัญหาเมทริกซ์ ใน Mathematica คุณสามารถกำหนดเมทริกซ์เบาบางโดยใช้การจับคู่รูปแบบ

อย่างไรก็ตามSparseArrayได้รับการแนะนำใน Mathematica 5.0 ดังนั้นเราจึงไม่สามารถใช้ใน Mathematica 1.0 ได้

นี่คือวิธีการแก้ปัญหาที่ทำงานใน Mathematica 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];
]

เราเขียนไม่ได้f[i_, 1 | i_ | n] = "N"เพราะAlternativesเปิดตัวใน Mathematica 2.0

ภารกิจที่ 3

เราสามารถใช้ฟังก์ชั่นในตัว:

gcd = GCD

หรือเราสามารถใช้นิยามของ GCD:

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

หรือเราสามารถใช้LCMได้แม้ว่าโดยทั่วไป LCM จะคำนวณจาก GCD:

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

หรือเราสามารถใช้อัลกอริทึมแบบยุคลิดกับการจับคู่รูปแบบ:

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

หรือเป็นฟังก์ชั่นที่ไม่ระบุชื่อ:

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

ฟังก์ชั่นทั้งหมดข้างต้นได้รับการแนะนำใน Mathematica 1.0

1999 - XSLT

World Wide Web Consortium (W3C) สร้าง XSLT สำหรับการเปลี่ยน XML เป็น HTML, ข้อความ, ฯลฯ ตัวอย่างต่อไปนี้ถือว่าการป้อนข้อมูลถูกปิดล้อมอยู่ใน<input>..</input>แท็ก

ภารกิจที่ 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>

อันนี้ง่าย มันตรงกับinputแท็กที่ระดับบนสุดและแทนที่ด้วยเอาต์พุตที่ต้องการ

ภารกิจที่ 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>

หนึ่งนี้กำหนด 2 แม่แบบเวียนเกิดและloop กับพารามิเตอร์และจะสร้างผลลัพธ์ที่ต้องการสำหรับการเริ่มต้นที่ตำแหน่ง ด้วยพารามิเตอร์จะสร้างช่องว่างspacesloopinnispacesnn

ภารกิจที่ 3

ข้อมูลนี้จะต้องอยู่ใน<input><num>..</num><num>..</num></input>แท็ก

<?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>

อันนี้เป็นเพียงเทมเพลตแบบเรียกซ้ำgcdที่ใช้อัลกอริทึมแบบยุคลิด

2014 - CJam

CJamถูกสร้างขึ้นโดยผู้ใช้ PPCG aditsuและได้รับการปล่อยตัวรอบเมษายน 2014

"สวัสดีชาวโลก!" ตัวแปร

"CJam was made in 2014!"

CJam พิมพ์เนื้อหาของสแต็คโดยอัตโนมัติในตอนท้ายของโปรแกรม

ASCII Art N

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

คำอธิบายรหัส:

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

ใช้ความสูง / ความกว้างของ N เป็นอินพุตผ่าน STDIN ลองออนไลน์ได้ที่นี่

GCD

l~{_@\%}h;

ใช้ตัวเลขสองตัวเป็นอินพุตผ่าน STDIN ลองออนไลน์ได้ที่นี่

1990 - Haskell

Haskell เป็นภาษาที่ได้รับความนิยม (หรือฉันควรจะพูดว่า: ภาษาที่ได้รับความนิยมมากที่สุด ) มันออกมาจากกระแสหลักโดยรูปแบบการประเมินที่ผิดปกติ (โดยค่าเริ่มต้นทุกอย่างขี้เกียจหรือทางเทคนิคไม่เข้มงวด) และโดยระบบประเภทอิง Hindley-Milner ซึ่งแม้ตอนนี้ยังคงเป็นหนึ่งในผู้ที่ทรงพลังที่สุด

ภารกิจที่ 1

main = putStrLn "Haskell was made in 1990!"

ภารกิจที่ 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

การสาธิตพิมพ์รายการที่ไม่มีที่สิ้นสุดทั้งหมด (จนกว่าผู้ใช้จะยกเลิกหรือโลกสิ้นสุด ... )

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

...

แน่นอนว่าคุณสามารถเข้าถึงหนึ่งในสิ่งเหล่านี้ได้อย่างง่ายดายเพียงเข้าถึงองค์ประกอบเดียวของรายการที่ไม่มีที่สิ้นสุด:

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

ภารกิจที่ 3

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

1972 - INTERCAL

และคุณคิดว่า Fortran และ Cobol นั้นแปลก นี่มันบ้ามาก!

ภารกิจที่ 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

ฉันจะไม่พยายามอธิบายระบบอินพุตและเอาต์พุตของ INTERCAL แค่อ่านเรื่องนี้และหวังว่าคุณจะไม่ตาย

ภารกิจที่ 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

คุณงามความดี เรื่องนี้ทำให้ฉันคิดออก หมายเลขฉลากไม่เป็นระเบียบดังนั้นจึงสะท้อนว่า ฉันจะไม่พยายามอธิบายสิ่งนี้หากไม่มีใครถาม

ภารกิจที่ 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

คนนี้ตาดง่ายขึ้น เนื่องจาก ... ความแปลกประหลาดของ INTERCAL คุณต้องป้อนตัวเลขดังนี้:

THREE FIVE

ตัวอย่างเช่นหากต้องการรับ GCD ของ 42 และ 16 ฉันจะป้อน:

FOUR TWO
ONE SIX

มันพิมพ์ตัวเลขเป็นเลขโรมัน ... เพราะนั่นคือ INTERCAL สำหรับคุณ!

1967 - APL

ในปี 1957 ที่มหาวิทยาลัย Harvard, Ken Iverson เริ่มพัฒนาสัญกรณ์คณิตศาสตร์สำหรับการจัดการอาร์เรย์ ในช่วงปี 1960 สัญกรณ์ของเขาได้รับการพัฒนาเป็นภาษาการเขียนโปรแกรมที่ IBM การนำบางส่วนไปใช้ครั้งแรกนั้นถูกสร้างขึ้นในปี 1963 และมันยังถูกใช้ในโรงเรียนมัธยมเพื่อสอนนักเรียนเกี่ยวกับหน้าที่เหนือธรรมชาติ การนำไปใช้งานแบบเต็มรูปแบบที่ใช้งานได้ต้องรอจนถึงปี 1965 เป็นเวลาสองปีที่ IBM ใช้ภายในเท่านั้น ในปีพ. ศ. 2510 ไอบีเอ็มเปิดตัวล่าม APL ให้กับสาธารณชนที่ทำงานบนคอมพิวเตอร์ IBM 1130 ซึ่งเสร็จในปี 2509 คุณสามารถเข้าใจได้ว่าการเลือกปีเป็นเรื่องยาก แต่ฉันคิดว่ามันควรจะเป็นปี 1967 เนื่องจากนี่เป็นปีแรกที่มีการดำเนินการอย่างเต็มรูปแบบต่อสาธารณชน ถ้าใครไม่เห็นด้วยจริงๆฉันก็เปลี่ยนได้

ซอร์สโค้ดสำหรับ APL \ 360 ออนไลน์อยู่เช่นเดียวกับอีมูเลเตอร์ นี่คือสิ่งที่ฉันใช้ในการทดสอบตัวอย่างเหล่านี้ มันเริ่มต้นตั้งแต่ปี 1967 และพร้อมกับ APL \ 1130 (สำหรับ IBM 1130 ดังกล่าวข้างต้น) มันเป็นต้นฉบับจริงที่มากหรือน้อย อย่างที่คาดไว้มันเป็นสิ่งดั้งเดิม มันขาดการสนับสนุนสำหรับ niceties เช่นอักษรตัวพิมพ์เล็กผู้ประกอบการใด ๆเพียง แต่ทำงานร่วมกับฟังก์ชั่นในตัวและชุดของฟังก์ชั่นในตัวคือเบาบางมาก (โดยเฉพาะอย่างยิ่ง∨เป็นเพียง orและไม่ ได้เป็นสองเท่าgcd) ต้นฉบับคำอธิบายแบบเต็มมีอยู่ ที่นี่แต่ฉันสังเกตเห็นว่าเวอร์ชันที่ฉันมียังไม่สมบูรณ์ด้วยความเคารพต่อเอกสาร⍎นั้น

ฉันได้จัดทำโปรแกรมทั้งในรูปแบบ Unicode (เพื่อให้คุณสามารถอ่านได้) และในการเข้ารหัสดั้งเดิม (เพื่อให้คุณสามารถตัดและวางลงในหน้าต่าง APL ของอีมูเลเตอร์)

ไม่น่าเชื่อโปรแกรมเหล่านี้ทำงานอย่างถูกต้องโดยไม่มีการเปลี่ยนแปลงใด ๆ (ยกเว้นการเข้ารหัส) ในรุ่น Dyalog, NARS2000 และ GNU APL รุ่นใหม่ ดังนั้นฉันคิดว่าฉันได้พบวิธีเขียน APL แบบพกพา: แค่แกล้งทำเป็นปี 1967!

ภารกิจที่ 1:

Unicode:

⎕←'APL WAS MADE IN 1967!'

APL \ 360:

L[Kapl was made in 1967ÝK

ภารกิจที่ 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'

ภารกิจที่ 3:

ฉันได้แก้ไขวิธีนี้ซ้ำแล้วซ้ำอีกมาตรฐาน ในทางทฤษฎีคุณสามารถทำสิ่งที่ฉลาดและมีอาเรย์ได้เหมือนคำตอบ J อย่างไรก็ตามในทางปฏิบัตินั้นมีการใช้หน่วยความจำ O (N) และความยากลำบากอย่างรวดเร็วของ Flower-Power-ยุคซอฟแวร์และซอฟต์แวร์

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

รอมากกว่าหนึ่งวันเติมใครบางคนในปี 1996 ดังนั้นฉันสามารถเติมทับทิม ถ้าอย่างนั้นทำไมไม่เรียน OCaml ดูคล้ายกับ Haskell ...

สวัสดีชาวโลก

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;;

สตริงที่ไม่แน่นอน

GCD

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

ไม่==และมัดmodนั่นน่ารัก

2005 - โหมโรง

โหมโรงเป็นภาษาที่สนุกมากที่มีรหัสที่มาประกอบด้วยหลาย "เสียง" ซึ่งจะดำเนินการในแบบคู่ขนานและที่ฉันจริงๆเพลิดเพลินไปกับการแก้ปัญหาในการ มันหมายถึงการเป็นตัวแทน ASCII ของFugueภาษาน้องสาวซึ่งจริง ๆ แล้วใช้ไฟล์. midi เป็นซอร์สโค้ดและเข้ารหัสคำแนะนำที่พบในโหมโรงเป็นช่วงเวลาในท่วงทำนองของเสียง

โหมโรงค่อนข้างเรียบง่าย แต่ทัวริงสมบูรณ์ (หากคุณใช้อย่างน้อย 2 เสียง) อย่างที่ฉันบอกไปแล้วว่าเสียง (บรรทัดของรหัส) นั้นถูกเรียกใช้งานพร้อมกันทุกคอลัมน์ แต่ละเสียงทำงานบนสแต็กของตัวเองซึ่งเริ่มต้นด้วยเลขศูนย์ไม่ จำกัด โหมโรงรองรับคำแนะนำต่อไปนี้:

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 '('.

หมายเหตุเพิ่มเติมบางส่วน:

• เสียงที่เป็นวงจรดังนั้น^ในการคัดลอกเสียงที่ดีที่สุดจากเสียงด้านล่าง (และในทางกลับกัน)
• หลาย?และ!ในคอลัมน์เดียวกันจะถูกดำเนินการจากบนลงล่าง
• ตามสเปคภาษา , ?และ!การอ่านและการเขียนตัวอักษรด้วยรหัสตัวอักษรที่สอดคล้อง อย่างไรก็ตามล่าม Pythonยังมีสวิตช์ในรหัสเพื่อพิมพ์ตัวเลขแทน สำหรับวัตถุประสงค์ในการทดสอบจริง ๆ แล้วฉันใช้เวอร์ชั่นที่แก้ไขซึ่งสามารถอ่านตัวเลขแทนตัวอักษรได้ แต่ฉันทามติที่นี่คือตัวเลขจริง ๆ สามารถกำหนดให้เป็นค่าไบต์ดังนั้นการแก้ไขเหล่านี้จึงไม่จำเป็นต้องทำให้โปรแกรมที่ถูกต้องสามารถจัดการกับตัวเลขได้
• การจับคู่(และ)ไม่จำเป็นต้องเป็นเสียงเดียวกัน เสียงที่ใช้สำหรับเงื่อนไขเป็นเสมอหนึ่งที่(ปรากฏขึ้น ดังนั้นตำแหน่งแนวตั้งของสิ่งที่)ไม่เกี่ยวข้องทั้งหมด
• เนื่องจากลักษณะของการดำเนินการของ Prelude พร้อมกันคำสั่งใด ๆ ในคอลัมน์เดียวกับ a (จะถูกดำเนินการเพียงครั้งเดียวก่อนที่ลูปจะเริ่มต้นและไม่คำนึงว่าจะป้อนลูปหรือไม่ ในทำนองเดียวกันคำสั่งใด ๆ ในคอลัมน์เดียวกับ a )จะถูกดำเนินการในตอนท้ายของการวนซ้ำแต่ละครั้งไม่ว่าลูปจะออกจากการวนซ้ำหลังจากการทำซ้ำนี้หรือไม่

ฉันจะแสดงรายการทั้งสามรายการก่อนโดยไม่แสดงความคิดเห็นมาก คุณสามารถหาคำอธิบายที่ครอบคลุมด้านล่าง

โปรแกรม

"สวัสดีชาวโลก!" ตัวแปร

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

NUMERIC_OUTPUT = Falseหากคุณกำลังใช้ล่ามหลามตรวจสอบให้แน่ใจว่า

ASCII Art N

      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#

เพื่อความสะดวกในการใช้งานโปรแกรมนี้ได้รับประโยชน์จากการอ่านอินพุตเป็นตัวเลข แต่เอาต์พุตต้องไม่เป็นตัวเลข ดังนั้นหากคุณใช้ล่าม Python ที่แก้ไขแล้วให้ตั้งค่า

NUMERIC_INPUT = True
NUMERIC_OUTPUT = False

GCD

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

ใช้กับอินพุต / เอาต์พุตตัวเลขทั้งหมดได้ดีที่สุด

NUMERIC_INPUT = True
NUMERIC_OUTPUT = True

คำอธิบาย

"สวัสดีชาวโลก!" ตัวแปร

นี่ค่อนข้างตรงไปตรงมา ฉันใช้เสียง 3 Prelude was made in 2005!จะต่อเนื่องสร้างรหัสอักขระสำหรับตัวละครทั้งหมดใน ฉันเริ่มต้นด้วยการคำนวณ8 + 9*8 = 80ซึ่งเป็นรหัสตัวอักษรของP:

 9(1-)
 8 8+

หลังจากนั้นฉันก็แค่คัดลอกรหัสตัวอักษรก่อนหน้าและเพิ่มหรือลบส่วนต่างให้กับอีกอัน นี่คือรหัส แต่แต่ละตัว!ถูกแทนที่ด้วยตัวละครที่จะถูกพิมพ์ (และ_สำหรับช่องว่างและ%สำหรับตัวเลข):

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

สุดท้าย55+!พิมพ์บรรทัดใหม่ที่ต่อท้ายเพียงเพราะดีกว่า

ในฐานะที่เป็นหมายเหตุด้านข้างจำนวนเสียงนั้นค่อนข้างเหมาะสมสำหรับงานนี้ แต่ 3 ค่อนข้างสะดวกเพราะมันเป็นหมายเลขที่ใหญ่ที่สุดที่ทุกเสียงสามารถเข้าถึงเสียงอื่น ๆ ได้โดยตรง

ASCII Art N

      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#

ด้วย 5 เสียงนี่เป็นหนึ่งในโปรแกรมที่ซับซ้อนที่สุดที่ฉันเคยเขียน เสียงประมาณมีวัตถุประสงค์ดังต่อไปนี้:

1. เป็นเสียงผู้ช่วยที่เก็บN-1ไว้ใช้ในลูปด้านใน
2. นี่คือเสียง "main" ซึ่งอ่านอินพุตมีสวิตช์ที่สำคัญและยังมีลูปด้านนอก (เช่นเสียงที่อยู่เหนือแถว)
3. วิธีนี้จัดเก็บ a 32ไปยังพื้นที่พิมพ์ที่สะดวก
4. สิ่งนี้มีลูปด้านใน (อันหนึ่งอยู่เหนือคอลัมน์)
5. นี้เก็บ78เพื่อพิมพ์Ns

ลองดูส่วนของรหัสทีละส่วนกัน ก่อนอื่นฉันสร้าง32as -4 + 9*4และ78as 6 + 9*8:

9(1-)
4-4+

6 8+

ตอนนี้ฉันกำลังพิมพ์เดี่ยวN(เพราะเราต้องการเสมอ) ในขณะที่อ่านอินพุตNและจัดเก็บN-1และN-2ในสองเสียงแรก:

      v2-
     ?1-

     v!

ถัดไปมี "ห่วง" N-1ปรับอากาศบน ในตอนท้ายของลูปเสียงที่สองจะลดลงเป็นเสมอ0และลูปจะออกหลังจากการวนซ้ำครั้งแรก if(N > 1){...}เพื่อเป็นหลักนี้เท่านั้น หลังจากวนรอบเราพิมพ์บรรทัดใหม่ขึ้นบรรทัดเดียว ในการสรุปเราได้กรอบดังต่อไปนี้:

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

ภายในเงื่อนไขนี้เราจะN-2เว้นวรรคและเดี่ยวNเพื่อทำให้แถวแรกเสร็จสมบูรณ์และเรายังเก็บN-1เสียงแรกสำหรับการใช้ในอนาคต:

         (1-)v         
          v!  

             v!

ตอนนี้เนื้อจริงของรหัส อย่างแรกคือมีลูปด้านนอกซึ่งพิมพ์N-1แถว สำหรับแต่ละแถวเราครั้งแรกที่Nพิมพ์ขึ้นบรรทัดใหม่และ จากนั้นเราวนรอบN-2เวลาพิมพ์ช่องว่างหรือNs (เพิ่มเติมในภายหลัง) และในที่สุดเราก็พิมพ์อื่นN:

               1-55+!  

                v1-v!(               )v!
               v#

ในที่สุดความสนุก: การพิมพ์แต่ละแถว (และรับตำแหน่งที่Nเหมาะสม) ไม่มีจริงๆถ้า / อื่น ๆ ในโหมโรงดังนั้นฉันต้องสร้างมันด้วยตัวเองโดยใช้สองลูปกับเสียงที่แตกต่างกัน สามารถรับสภาพได้อย่างง่ายดายโดยการลบตัวแปรลูปด้านในและด้านนอก - เราได้รับ0ถ้าเราต้องการพิมพ์Nและสิ่งที่ไม่เป็นศูนย์ถ้าเราต้องการพิมพ์พื้นที่

ความคิดพื้นฐานของหาก / อื่นในโหมโรงคือการใส่ห่วงหลังจากมูลค่าที่เกี่ยวข้อง - ที่ "ถ้า" (หรือที่ไม่ใช่ศูนย์) 0รหัสและออกทันทีโดยการผลักดัน ในเสียงอื่นคุณเก็บค่าที่ไม่เป็นศูนย์และลูปอื่นหลังจากลูป"if" ในระหว่างการวนรอบ "if" คุณใส่ศูนย์ไว้ด้านบนของเสียงอื่นเพื่อป้องกันไม่ให้มีการดำเนินการ "else" มีความยืดหยุ่นในการที่คุณจะผลักดันค่าศูนย์ที่ด้านบนของค่าที่ไม่เป็นศูนย์หรือเพียงแค่ทิ้งค่าที่ไม่ใช่ศูนย์หากมีค่าที่ต่ำกว่าศูนย์ แต่นี่เป็นแนวคิดทั่วไป คุณอาจต้องทำการล้างข้อมูลในภายหลังหากคุณต้องการใช้เสียงที่เกี่ยวข้องต่อไป นี่คือลักษณะของรหัส:

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

และนั่นมัน!

GCD

นี่คือ "เพียง" การดำเนินการซ้ำของอัลกอริทึมแบบยุคลิด แต่โมดูโล่ใน Prelude ค่อนข้างน่ารำคาญส่วนใหญ่เป็นเพราะคุณไม่สามารถตรวจสอบได้อย่างง่ายดายว่าตัวเลขนั้นเป็นบวกหรือลบ รหัสนี้ใช้ประโยชน์จากการติดตั้งแบบsignum ที่ผมเขียนมานานแล้ว คือส่วนใหญ่ของรหัสเพียงแค่เปลี่ยนตัวเลขลง-1, หรือ0 นี้สามารถได้อย่างง่ายดายแล้วจะกลายเป็นเงื่อนไขสำหรับตัวเลขบวกหรือลบโดยการเพิ่มหรือลด11

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

คราวนี้เรามีสี่เสียง เสียงแรกเพียงแค่ติดตามbและมีเงื่อนไขการเลิกจ้างหลัก (เช่นวงออกจากเมื่อbกลายเป็น0) เสียงที่สองมีaและด้วยความช่วยเหลือของเสียงที่สามและสี่คำนวณก่อนที่จะแลกเปลี่ยนผลกับก่อนหน้านี้a % b bสุดท้าย!พิมพ์เมื่อab == 0

ลองดูที่Signumส่วนแรก:

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

หมายเลขอินพุตnพบได้ในเสียงแรกของเสียงนั้น (เสียงที่สองในโปรแกรมเต็มรูปแบบ) ผลลัพธ์จะจบลงที่เสียงด้านล่าง อีกสองเสียงคาดว่าจะว่างเปล่า (เช่นเต็มไปด้วยเลขศูนย์) โปรดสังเกตว่าถ้าหากn == 0จากนั้นทั้งสองลูปจะถูกข้ามและเสียงด้านล่างยังมี0อยู่สิ่งที่เราต้องการ

หากnไม่ใช่ศูนย์จะเป็นการป้อนลูปขนาดเล็กแรก เราดันศูนย์ให้ออกทันทีใส่สำเนาnกลางของเสียงกลางสองชุดและ1ลงบนเสียงล่าง ตอนนี้แนวคิดพื้นฐานคือการเพิ่มสำเนาหนึ่งของnในขณะที่ลดลงอีกสำเนาnหนึ่งจนกว่าหนึ่งของพวกเขาเข้าศูนย์ ในขณะที่ทำเช่นนั้นเสียงที่1อยู่ด้านล่างจะพลิกสัญญาณของมันตลอดเวลา (ซึ่งทำได้ง่ายโดยการลบมันออกจาก0ใต้เสียงบนสแต็ก) การตั้งค่านี้จะตั้งค่าให้เมื่อหมายเลขใดตัวเลขหนึ่งเป็นศูนย์เสียงด้านล่างจะมีเครื่องหมายที่ถูกต้อง

ตอนนี้โมดูโลจะถูกนำมาใช้โดยการลบbจากaจนกว่าผลจะเป็นลบ เมื่อสิ่งนั้นเกิดขึ้นเราจะเพิ่มbอีกครั้ง นั่นคือบิตนี้:

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

สังเกตการก่อสร้าง if / else ที่ด้านล่างซึ่งคล้ายกับที่ฉันใช้สำหรับงาน 2

2550 - เกา

Scratchเป็นภาษาที่ทำโดย MIT เพื่อการศึกษา ฉันเกี่ยวข้องกับเรื่องนี้มา 5 ปีแล้ว เพิ่มเติมในภายหลัง

ทั้งหมดเหล่านี้สามารถดูได้ที่นี่

ตอนนี้ฉันรีบมากและจะอธิบายตัวอย่างในภายหลัง หวังว่าพวกเขาจะอธิบายด้วยตนเองล่วงหน้า

ภารกิจที่ 1

ภารกิจที่ 2

ภารกิจที่ 3

2515 - ค

เราทุกคนรู้เกี่ยวกับ C ใช่ไหม? C ถูกสร้างขึ้นที่ Bell Labs พร้อมกับ Unix Unix ถูกเขียนเป็นส่วนใหญ่ใน C. อนุพันธ์ของ Unix ที่ทันสมัยทั้งหมดยังคงถูกเขียนส่วนใหญ่ในรูปแบบของ C. C มีอิทธิพลต่อภาษาการเขียนโปรแกรมจำนวนมาก มันอาจเป็นภาษาการเขียนโปรแกรมที่เก่าแก่ที่สุดที่ยังคงใช้กันอย่างแพร่หลายสำหรับการพัฒนาใหม่

C เองเป็นผู้สืบทอดของ B ซึ่งฉันหวังว่าจะจบลงในรายการนี้เช่นกัน ไม่มีภาษาการเขียนโปรแกรม 'A': B เป็นตัวแปรของ BCPL ซึ่งในทางกลับกันคือ CPL ที่ถูกปล้น ภาษาเหล่านี้ไม่ได้รับความนิยมมากนัก อย่างไรก็ตาม BCPL เป็นภาษาที่เขียนโปรแกรม "Hello World" ครั้งแรก อีกข้อเท็จจริงที่น่าสนใจคือ B มีทั้ง/* */และ//ความคิดเห็น แต่ C ลด//ความคิดเห็น พวกเขาได้รับการแนะนำให้รู้จักกับ C ในภายหลังด้วยมาตรฐาน C99

โปรแกรม C ที่นี่ได้รับการทดสอบกับคอมไพเลอร์ Unix V5 C จากปี 1974 นี่เป็นคอมไพเลอร์ C ที่เก่าแก่ที่สุดที่ฉันสามารถค้นหาและไปทำงานได้และโปรแกรมเหล่านี้จะไม่คอมไพล์ในคอมไพเลอร์ C สมัยใหม่ (หนึ่งในการเปลี่ยนแปลงที่ทำคือผู้ประกอบการกลายพันธุ์เช่น+=เคยเขียน=+ )

#include <... >ยังไม่มี ไม่ได้ทำไลบรารีมาตรฐานมากนัก atoiฉันได้เขียนของตัวเอง ฉันไปถึงซอร์สโค้ด V5 บางส่วนเพื่อพิจารณาว่าสิ่งใดบ้างที่อนุญาตและไม่ใช่ เวอร์ชันที่ฉันใช้เป็นเวอร์ชันแรกที่รวมstruct s แต่เนื่องจากฉันไม่ได้ใช้และไวยากรณ์ดูเหมือนจะไม่เปลี่ยนแปลงมากนักจนกระทั่ง V7 (เหมือนกับ K&R C) นี่อาจทำงานกับเวอร์ชันก่อนหน้าได้เช่นกัน

ฉันพยายามเขียนโค้ดในสไตล์เดียวกับที่ใช้กับซอร์สโค้ด V5 (ไม่ว่าจะเป็นที่สอดคล้องกันชะมัด)

ดูที่นี่ สำหรับลิงก์ไปยัง Unix V5 โปรแกรมจำลองและคำแนะนำในการทำให้มันทำงานบนคอมพิวเตอร์ที่ทันสมัย

ภารกิจที่ 1

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

ภารกิจที่ 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]));
}

ภารกิจที่ 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])));
}

2552 - ไอดริส

ไอดริสเป็นภาษาที่ใช้งานได้อย่างบริสุทธิ์และพิมพ์ได้จริงซึ่งเน้นการใช้งานจริงสำหรับแอพพลิเคชั่นในโลกแห่งความเป็นจริงนอกเหนือจากการเสนอความเป็นไปได้ในการพิสูจน์ที่เข้มงวดอย่างยิ่ง

ภารกิจที่ 1

module Main

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

ภารกิจที่ 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

อันนี้ไม่ได้เป็นโปรแกรม แต่เป็นเพียงฟังก์ชั่น (แม่นยำมากขึ้นขึ้นอยู่กับค่า ) ทำให้ตัวอักษร N ที่ต้องการเป็นอาร์เรย์สองมิติ

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

ภารกิจที่ 3

module gcd

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

โปรดทราบว่าฉันต้องเลือกชื่อgcd'เพราะตามที่gcdกำหนดไว้แล้วในโหมโรง 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

เนื่องจากเรามี CJam เราก็อาจมี Pyth เพื่อความสมบูรณ์ :)

Pyth เป็นภาษาการเล่นกอล์ฟโดย@isaacgซึ่งรวบรวมลงใน Python เป็นที่น่าสังเกตว่าเป็นขั้นตอนและใช้สัญกรณ์นำหน้า Pyth ปรากฏตัวครั้งแรกรอบมิถุนายน 2014

"สวัสดีชาวโลก!" ตัวแปร

"Pyth was made in 2014!

สังเกตว่าไม่มีเครื่องหมายอัญประกาศปิดซึ่งเป็นทางเลือกถ้าโปรแกรม Pyth สิ้นสุดในสตริง

ASCII Art N

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

ลองมันออนไลน์ Python ที่เทียบเท่าคือ:

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

หรือขยาย (บรรทัดแรกและบรรทัดที่สามเป็นนัย):

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

โปรแกรมนี้ใช้อัลกอริทึมแบบยุคลิดและใช้ตัวเลขสองตัวคั่นด้วยบรรทัดใหม่ ลองมันออนไลน์

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

i.uQจะสั้นกว่านี้หากเราใช้ builtin สำหรับ GCD นี่เทียบเท่าprint(gcd(*eval(input())))(ใช้ตัวเลขสองตัวคั่นด้วยเครื่องหมายจุลภาคเป็นอินพุต)

2507- ดาร์ทเมาท์เบสิค

BASICเป็นตระกูลภาษาโปรแกรมระดับสูงทั่วไปที่มีปรัชญาการออกแบบเน้นการใช้งานง่าย ในปี 1964 John G. Kemeny และ Thomas E. Kurtz ได้ออกแบบภาษาเบสิกดั้งเดิมที่ Dartmouth College ในรัฐนิวแฮมป์เชียร์ พวกเขาต้องการให้นักเรียนในสาขาอื่นที่ไม่ใช่วิทยาศาสตร์และคณิตศาสตร์สามารถใช้คอมพิวเตอร์ได้

ฉันกำลังดูคู่มือนี้เกี่ยวกับ BASIC จากปี 1964 และโปรแกรมจำลองการทำงานของระบบแบ่งปันเวลา Darthmouth นี้ เซิร์ฟเวอร์ยังคงทำงานอยู่ แต่น่าเสียดายที่การลงทะเบียนบัญชีดูเหมือนจะเป็นไปไม่ได้ สำหรับตอนนี้โปรแกรมเหล่านี้ในทางทฤษฎีควรทำงาน:

ภารกิจที่ 1

10 PRINT "BASIC WAS MADE IN 1964"
20 END

ภารกิจที่ 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

กำลังแสดงผลเช่น:

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

สังเกตว่าการพิมพ์อินพุตนั้นเป็นส่วนหนึ่งของโปรแกรม ( 70 DATA 5); READวิธีการเรียนการสอนที่ด้านบนดึงข้อมูลจากที่นั่น ไม่มีการต่อข้อมูลสตริง แต่ส่วนที่ 3.1 ของคู่มืออธิบายวิธีPRINTเขียนผลลัพธ์ไปยัง "โซน" แบบตารางบนเอาต์พุต

ภารกิจที่ 3

อัลกอริทึมของ 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

การแสดงผล:

2

2010 - WTFZOMFG

WTFZOMFG เป็นภาษาลึกลับขึ้นอยู่กับ Brainfuck มันถูกสร้างโดย Jay Songdahl ในปี 2010 "WTFZOMFG" ย่อมาจาก "What That Function? Zen Optimized Malicious File Gophers!" .

นี่คือคอมไพเลอร์สำหรับระบบ * ระวัง

ภารกิจที่ 1

'WTFZOMFG was made in 2010!\n"

ภารกิจที่ 2

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

คำอธิบาย:

ขอโทษ ฉันไม่สามารถเขียนคำอธิบายได้ดี

/                                           # 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
                                          ) # 

ภารกิจที่ 3

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

อัลกอริทึมแบบยุคลิด WTFZOMFG ไม่มีคำสั่งสำหรับ mod ดังนั้นฉันต้องใช้d(หาร), m(คูณ) และs(ลบ)

2552 - ไป

Go คือภาษาโปรแกรมที่พัฒนาโดย Google การพัฒนาเริ่มต้นขึ้นในปี 2550 แต่เริ่มประกาศในเดือนพฤศจิกายน 2552

Go เป็นภาษาที่พิมพ์แบบคงที่ได้รับอิทธิพลจาก C ซึ่งเน้นความกระชับความเรียบง่ายและความปลอดภัย

ภารกิจที่ 1:

package main
import "fmt"

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

บรรทัดแรกประกาศแพ็คเกจของรหัส แม้แต่ตัวอย่างง่ายๆในการพิมพ์หนึ่งบรรทัดก็จำเป็นต้องเป็นส่วนหนึ่งของแพ็คเกจเดียวกัน mainและปฏิบัติการที่เรียกว่าเสมอ

ภารกิจที่ 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 มีการประกาศตัวแปรที่ค่อนข้างกระชับ ( i := 0เหมือนกับvar i int = 0) และคอมไพเลอร์จะกำหนดประเภท นี่เป็นคุณสมบัติทั่วไปในภาษาแบบไดนามิก การใช้สัญกรณ์สั้น ๆ นี้ยังง่ายต่อการกำหนดฟังก์ชั่นให้กับตัวแปร ( f := func(x int) int {/* Code */}) และสร้างการปิด

ภารกิจที่ 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))
}

ที่นี่คุณสามารถดู a, b = b, a%bไวยากรณ์ซึ่งดีจริงๆ ฉันไม่รู้ชื่อที่แน่นอน แต่ใน Python มันเรียกว่า tuple unpacking ใช้วิธีเดียวกับที่คุณสามารถคืนค่าหลายค่าจากฟังก์ชั่น ( func f() (int, string) { return 42, "Hallo"})

สิ่งที่เกิดขึ้นในรหัสนี้ก็คือลูป ห่วงสำหรับเป็นวงเดียวในไป ไม่มีลูปในขณะที่หรือทำในขณะที่ลูป แต่คุณสามารถสร้างสิ่งที่เทียบเท่าสำหรับ while loop for condition {}หรือ infinite loop for {}ได้อย่างง่ายดาย

2534 - ธ

ประวัติภาษา

ในช่วงปลายทศวรรษ 1980 Guido van Rossum เริ่มวางแผนงานอดิเรกของ Python ชื่อของมันมาจาก Monty Python Flying Circus รายการโทรทัศน์ของอังกฤษที่ Rossum เป็นแฟน การใช้งาน Python ครั้งแรกเริ่มขึ้นในปี 1989 และได้เปิดตัวในปี 1991 มันได้รับความนิยมอย่างมากในช่วงหลายปีที่ผ่านมากลายเป็นภาษาที่ถูกเลือกสำหรับหลักสูตรวิทยาการคอมพิวเตอร์เบื้องต้นจำนวนมาก

"สวัสดีชาวโลก!" ตัวแปร

print("Python was made in 1991!")

printหมายเหตุวงเล็บรอบการป้อนข้อมูลเพื่อ แม้ว่าไวยากรณ์นี้จะทำงานใน Python 2 แต่โดยทั่วไปแล้วใน Python 2 คุณจะไม่ใส่วงเล็บเหล่านี้ อย่างไรก็ตามพวกเขาจำเป็นต้องใช้ใน Python 3 ตามที่ Zach Gates แนะนำไว้เราจะใช้วงเล็บในเพื่อให้แน่ใจว่ารหัสที่แสดงในที่นี้จะใช้ได้กับทุกเวอร์ชั่น

ASCII Art N

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

defฟังก์ชั่นจะมีการกำหนดใช้ สตริงจะดำเนินการใช้และสตริงซ้ำกับ+*

GCD

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

โปรดทราบว่า Python ต้องการช่องว่างที่มีโครงสร้าง

2511 - อัลกอล 68

Algol 68 ได้ถูกกำหนดโดย IFIP Working Group 2.1 ในฐานะผู้สืบทอดต่อ Algol 60

มันเป็นภาษาเชิงการแสดงออกซึ่งทุกอย่างมีค่า นอกจากนี้ยังเป็นมุมฉากซึ่งคุณสามารถใช้โครงสร้างใด ๆ ในทางใดทางหนึ่ง ซึ่งหมายความว่านิพจน์สามารถอยู่ใน RHS และ LHS ของการมอบหมายตัวอย่างเช่น

โครงสร้างการควบคุมทั้งหมดมีรูปแบบย่อเช่นเดียวกับแบบยาวโดยใช้นิพจน์ นอกจากนี้ยังอนุญาตให้คำจำกัดความของผู้ประกอบการ

เป้าหมายของภาษาที่อ้างถึง:

เป้าหมายหลักและหลักการออกแบบของ ALGOL 68:

• ความสมบูรณ์และความชัดเจนของคำอธิบาย
• การออกแบบมุมฉาก
• การรักษาความปลอดภัย
• อย่างมีประสิทธิภาพ
• การตรวจสอบโหมดคงที่
• การแยกโหมดอิสระ
• รวบรวมอิสระ
• การเพิ่มประสิทธิภาพวนรอบ
• การเป็นตัวแทน - ในชุดตัวละครน้อยที่สุดและใหญ่ขึ้น

โปรแกรมเหล่านี้ได้รับการทดสอบกับล่าม Algol 68 Genieซึ่งเป็นการใช้งานที่สมบูรณ์ของภาษา

คุณสมบัติบางอย่างที่โปรแกรมเมอร์สมัยใหม่อาจพบแตกต่างกันคือไม่อนุญาตให้ใช้ข้อความว่างเปล่า คุณไม่สามารถเพิ่มได้;ทุกที่ คุณต้องใช้SKIPคำสั่งถ้าคุณต้องการไม่มีอะไรชัดเจน นอกจากนี้ยังอนุญาตให้เขียนโปรแกรมพร้อมกันได้ง่ายมาก อัลกอล 68 ยังใช้คำหลักข้างหลังเป็นเทอร์มิเนเตอร์เช่นesac , od , fiเป็นต้น

ภาษามีการใช้การแทนการเขียนรหัสที่ใช้แบบอักษรจำนวนมากที่แสดงคำหลักเป็นตัวหนาและตัวระบุเป็นตัวเอียงเช่น ในเวลาและอาจจะยังคงไม่มีคอมไพเลอร์ใช้คุณลักษณะของการออกแบบนี้ ภาษาอนุญาตให้มีการแสดงรูปธรรมที่แตกต่างกันหลายรูปแบบของโปรแกรมโดยใช้โหมดการหยุด โปรแกรมนี้อนุญาตให้เตรียมโดยใช้ชุดอักขระที่ จำกัด เช่นอาจพบได้ในคอมพิวเตอร์ในทศวรรษที่ 1960 พิจารณาส่วนโปรแกรมสั้น ๆ ซึ่งจะแสดงเป็น:

ถ้า ฉัน < 0 แล้ว ข้าม สาย

สิ่งนี้สามารถเตรียมได้สำหรับคอมไพเลอร์ในโหมดสโตรไพม์เป็น:

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

ในโหมดdot stropping สิ่งนี้จะเป็น:

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

ในกรณีที่โหมดการหยุดนี่จะเป็น:

IF i < 0 THEN SKIP FI

ฉันมีความชื่นชอบอย่างมากกับภาษานี้ในขณะที่ฉันทำงานกับหนึ่งในการใช้งานคอมไพเลอร์เช่นเดียวกับการเขียนโปรแกรมในภาษานี้เป็นเวลาหลายปีโดยเฉพาะ

ภารกิจที่ 1

พิมพ์ (("Algol 68 ทำในปี 1968!" ขึ้นบรรทัดใหม่ ))

จุดที่ควรทราบที่นี่คือเครื่องหมายวงเล็บคู่ นี่เป็นเพราะการพิมพ์เป็นฟังก์ชั่นที่รับอาร์กิวเมนต์เดี่ยวซึ่งเป็นอาร์เรย์ความยาวผันแปรของการรวมกันทุกประเภท วงเล็บด้านในเป็นตัวสร้างอาร์เรย์ นี่คือวิธีจัดการความแตกต่างในภาษาที่พิมพ์อย่างนี้

ในกรณีที่การลูบโหมด:

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


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

ภารกิจที่ 2

     int n ;
     อ่าน (( n ));
     สำหรับ i จาก 1 ถึง n ทำ
          สำหรับ j จาก 1 ถึง n ทำ
               ¢ที่นี่เราใช้ตัวย่อ IF ข้อ¢
               พิมพ์ ((( j = 1 หรือj = iหรือj = n |
                    "N"
               |
                    ""
               ))
          od ;
     พิมพ์ ((ขึ้นบรรทัดใหม่)))
     od

ในกรณีที่การลูบโหมด:

 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

ภารกิจที่ 3

     ¢เราสามารถกำหนดผู้ประกอบการของเราเองใน Algol 68 ¢
     op % = ( int , ข ) int :           (( ข= 0 | | ข% ( mod ข )           )); int i , j ; อ่าน (( i , j )); พิมพ์ (( i % j , ขึ้นบรรทัดใหม่ ))

              
         
              

    
    
    

ในกรณีที่การลูบโหมด:

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

2505 - SNOBOL

"StriNg Oriented และ symBOlic Language" เห็นได้ชัดว่าในช่วงแรกเรียกว่า Symbolic Expression Interpreter 'SEXI' ซึ่งจะต้องมีการเปลี่ยนแปลงเพื่อป้องกันไม่ให้คนในยุค 1960 เข้าสู่ยุคบลัชออนเมื่อส่งงาน เรื่องจริง.

นี่เป็นหนึ่งในภาษาแรกที่สามารถจัดการกับสตริงและรูปแบบได้ แท้จริงแล้วรุ่นแรกของ SNOBOL มีสตริงเป็นประเภทข้อมูลเท่านั้น วิชาคณิตศาสตร์ทำโดยการแยกวิเคราะห์ การเริ่มต้นใช้งานได้ทำบน IBM 7090 ดูเหมือนว่าจะหายไปนานอย่างน้อยฉันก็ไม่สามารถหาได้ สิ่งที่ฉันได้พบว่าเป็นกระดาษเดิมอธิบายว่ามันเช่นเดียวกับล่าม SNOBOL3 ใน Java ซึ่งสามารถทำงานบนคอมพิวเตอร์ที่ทันสมัย

SNOBOL แรกสวยมากเพียงจับคู่รูปแบบและคณิตศาสตร์ขั้นพื้นฐาน จากนั้น SNOBOL 3 ได้เพิ่มฟังก์ชั่นและเปลี่ยน I / O แต่ดูเหมือนว่าจะยังคงใช้งานได้ย้อนหลัง SNOBOL 4 เปลี่ยนไวยากรณ์และจากนั้นพัฒนาเป็นไอคอนซึ่งจะช่วยให้การจับคู่รูปแบบ แต่เกือบจะดูเหมือนภาษาการเขียนโปรแกรม "ปกติ" เป็นอย่างอื่น

โปรแกรมที่ฉันเขียนใช้ฟังก์ชั่นเฉพาะที่อธิบายไว้ในเอกสารต้นฉบับดังนั้นควรทำงานกับ SNOBOL ดั้งเดิมโดยมีข้อยกเว้นของ I / O ซึ่งฉันทำในรูปแบบ SNOBOL3 เพื่อให้ล่าม Java สามารถทำงานได้ จากกระดาษดูเหมือนว่าความแตกต่างคือ SNOBOL1 ใช้การจับคู่รูปแบบกับSYSตัวแปรพิเศษในขณะที่ SNOBOL3 ใช้ตัวแปรอินพุตและเอาต์พุต:

• การป้อนข้อมูล:
  • 1 SYS .READ *DATA*
  • 3 DATA = SYSPPT
• เอาท์พุท:
  • 1 SYS .PRINT 'A STRING' AND VARIABLES
  • 3 SYSPOT = 'A STRING' AND VARIABLES

การทำการทดแทนเหล่านี้ควรทำให้คุณได้ 'SNOBOL' ที่แท้จริง 1 แน่นอนว่าคุณไม่สามารถเรียกใช้มันได้

ภารกิจที่ 1

START   SYSPOT = 'SNOBOL WAS MADE IN 1962!'

ภารกิจที่ 2

สิ่งนี้แสดงให้เห็นถึงคณิตศาสตร์การจัดการสตริงและการควบคุมสายงาน SNOBOL3 มีฟังก์ชั่นที่มีประโยชน์เช่นEQการตรวจสอบความเท่าเทียมกัน; SNOBOL ดั้งเดิมไม่ได้ดังนั้นฉันจึงไม่ได้ใช้

* 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     

ภารกิจที่ 3

ครั้งแรกที่น่าเบื่อ สิ่งเดียวที่ควรทราบคือเช็คที่มีขนาดเล็กกว่าแสดงให้เห็นว่า SNOBOL เป็นตัวเน้นสตริงอย่างไร: (B - A) '-'หมายถึง "ผลลัพธ์ของ BA มีเครื่องหมายลบหรือไม่" SNOBOL3 สามารถทำได้เช่นLE(B,A)กัน แต่ SNOBOL 1 ไม่สามารถทำได้ (อย่างน้อยกระดาษก็ไม่ได้พูดถึง)

* 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

แน่นอนว่าเมื่อคุณมีภาษาที่อิงกับสายอักขระและการจับคู่รูปแบบทั้งหมดมันจะเป็นความอัปยศที่จะไม่ใช้การจับคู่รูปแบบและการแทนที่จริง ๆ ดังนั้นนี่คือหนึ่งใน GCDs ที่ใช้ระบบปฏิบัติการรวมถึงกิจวัตรสำหรับการแปลงไปและกลับจากระบบเดียวกัน

* 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 เป็นภาษาโปรแกรมฟรีและโอเพนซอร์ซที่พัฒนาและดูแลโดย Microsoft

เป้าหมายหลักคือ: เบราว์เซอร์ใด ๆ โฮสต์ใด ๆ ระบบปฏิบัติการใด ๆ โอเพ่นซอร์ส. เผยแพร่เมื่อตุลาคม 2012

สวัสดี TypeScript

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

ศิลปะ 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;
}

ลองออนไลน์และscreencastของมัน

2554 - โผ

Dart เป็นภาษาโปรแกรมโอเพนซอร์ซที่พัฒนาโดย Google ซึ่งพัฒนาขึ้นเพื่อใช้แทน Javascript (แม้ว่าจะเป็นภาษาจาวาสคริปต์ก็ตาม) มันถูกเปิดเผยโดย Google ในปี 2011 ในระหว่างการประชุม GOTO

"สวัสดีชาวโลก!" ตัวแปร:

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

ASCII Art N:

วิธีการ Bruteforce รันที่ 0 (n²) แต่ไม่ควรสำคัญถ้าคุณใช้ตัวเลขจำนวนมาก

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

วิธี Euclid อย่างง่ายรังเพลิงจาก Snap! ตัวอย่างข้างต้น

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 - สนิม

Rust เป็นวัตถุประสงค์ทั่วไป, หลายกระบวนทัศน์, ภาษาการเขียนโปรแกรมที่คอมไพล์ซึ่งพัฒนาโดย Mozilla Research มันถูกออกแบบมาให้เป็น "ปลอดภัยพร้อมกันภาษาที่ใช้งานได้" สนับสนุนการทำงานที่บริสุทธิ์พร้อมกันนักแสดงพร้อมกันขั้นตอนที่จำเป็นและรูปแบบเชิงวัตถุ วิกิพีเดีย

Task1

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

Task2

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!("");
    }
}

คำอธิบาย:

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

ดูแลการพิมพ์ในแนวตั้งเท่านั้น (ซ้ายและขวา|) และเส้นทแยงมุม ( \)

ภารกิจที่ 3

ใช้งานง่ายของ Euclidean_algorithm

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 - มัฟฟินMC

มัฟฟินMCเป็นภาษาแมโครทัวริงที่สมบูรณ์ (แต่จริงจัง) ที่ใช้งานง่ายและเรียบง่ายที่เขียนโดย Franck Porcher ( http://franckys.com ) ในช่วงกลางเดือนกุมภาพันธ์ 2558 จากเครื่องมือที่จำเป็นในการเพิ่มขีดความสามารถ สเปรดชีตที่จะใช้เป็นตัวควบคุม Front-end เพียงอย่างเดียวในการนำร่องและขับเคลื่อนการดำเนินการที่เกี่ยวข้องกับสินค้าคงคลังทั้งหมดที่เกี่ยวข้องกับเว็บไซต์ร้านค้าที่ใช้ Prestashop สำหรับแบรนด์แฟชั่นใหม่ของตาฮิติ: Mutiny Tahiti ( http://mutinytahiti.com - เร็ว ๆ นี้ เปิดตัว)

มัฟฟินMCเป็นตัวย่อสำหรับหมู่เล็ก ๆF unctional F lexible ในบรรทัดM Acro C ommand ภาษา

เพื่อตอบสนองความต้องการของเรา, มัฟฟินMCคุณสมบัติหลัก 's ได้รับการออกแบบรอบที่มีความยืดหยุ่นและมีประสิทธิภาพที่ 1 ระดับในตัวสร้างความหมายเหมือนiterators , ขี้เกียจประเมิน , หลาย functors , สตริงสินค้า

มัฟฟินMCดึงรากฐานมาจากการเขียนโปรแกรมที่ใช้งานได้ในเชิงปฏิบัติ (FLASH และ Perl) รองรับการเรียกซ้ำ (โดยไม่มีการปรับให้เหมาะสมใด ๆ ), พิมพ์แบบไดนามิกและกำหนดขอบเขตแบบไดนามิก (การผูกแบบตื้น) มันให้บริการโครงสร้างข้อมูลเดียวแก่ผู้ใช้เท่านั้นนอกเหนือจากอะตอมประเภทข้อมูลพื้นฐาน (อะตอม, สตริง, ตัวเลข): ​​รายการ!

มัฟฟินMCรายการความหมาย (ชนิด) ยืมความหมายของชุดพลังงานนั่นคือ:

1. การดำเนินการMuffin MCทั้งหมดให้รายการซึ่งอาจว่างเปล่า
2. การเข้าถึงองค์ประกอบรายการใด ๆ จะให้ค่าหนึ่งรายการที่ทำจากองค์ประกอบนั้นเสมอ (คิดว่าเป็นองค์ประกอบเดี่ยว)
3. รายการว่างเปล่าเป็นองค์ประกอบที่เป็นกลางในการดำเนินการรายการ

หากต้องการกระทบยอดกับสิ่งต่อไปนี้อาจช่วยได้:

• หนึ่งอาจมองเห็นรายการเป็นองค์ประกอบของชุดพลังงานของรายการที่มี cardinality มากที่สุด
• เห็นองค์ประกอบของรายการเป็นองค์ประกอบของชุดพลังงานของรายการที่เป็นซิงเกิลตันที่ทำจากองค์ประกอบนั้น
• เห็นภาพรายการที่ว่างเปล่าเป็นชุดที่ว่างเปล่า; นั่นคือองค์ประกอบเดียวของชุดพลังงานของชุดที่ว่างเปล่า

ดังนั้นการเข้าถึงองค์ประกอบลิสต์ที่ว่างจะทำให้ลิสต์นั้นว่างเปล่าและไม่ใช่ข้อผิดพลาด! อันที่จริงมัฟฟินMCพยายามอย่างหนักที่จะโยนข้อผิดพลาดให้น้อยที่สุดเท่าที่จะทำได้โดยขยายความหมายของความหมายของการดำเนินการแบบดั้งเดิมมากมาย

ภารกิจที่ 1

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

#(...)คือคำสั่งแมโครมัฟฟินMCสำหรับการใช้ฟังก์ชั่นในรายการอาร์กิวเมนต์ที่ไม่ผ่านการพิสูจน์นี่เป็นฟังก์ชั่นในตัวที่sayยืมมาจาก Perl

#(say 1 2 3 ...) มีหน้าที่เหมือนกับ map {say $_} (1,2,3,...)

ภารกิจที่ 2

กำหนดฟังก์ชั่น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()รูปแบบการทำงานที่สั้นที่สุด (88 ไบต์):

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

• =(var val...)คือคำสั่งมาโครMuffin MCเพื่อกำหนดตัวแปรหรือกำหนดใหม่

• $(var)เป็นคำสั่งแมโครMuffin MCเพื่อเข้าถึงค่าของตัวแปร มันยอมรับรูปแบบ$(v1 v2 ...)ในการเข้าถึงตัวแปรหลายตัวในครั้งเดียว

• =(* var1 val1 var2 val2 ...)เป็นส่วนขยายของคำสั่งแมโครมัฟฟินMC=(...)เพื่อจัดการกับการมอบหมายแบบขนาน

• ตัวแปร_1, _2, ... ถูกกำหนดขอบเขตแบบไดนามิก (กลไกการรวมที่ตื้น) และตั้งค่าโดยอัตโนมัติเพื่อผูกกับอาร์กิวเมนต์ของฟังก์ชัน ที่ยืมมาจาก Perl5 ตัวแปรระบบ#(จำนวนอาร์กิวเมนต์) และ@(รายการอาร์กิวเมนต์) จะถูกตั้งค่าโดยอัตโนมัติเช่นกัน

• ฟังก์ชั่นเป็นเพียงตัวแปรที่ผูกไว้กับคำสั่งMuffin MCจำนวนเท่าใดก็ได้

วิธีแก้ปัญหาที่น่าสนใจนี้มาจากการรวมมัฟฟินธรรมชาติสองอย่างเข้าด้วยกันคุณสมบัติในตัวของ MCในตัว:

1. MCมัฟฟิน I(...)คำสั่งแมโครเพื่อกำหนดขี่จักรยาน iterators ต่อมาใช้กับรูปแบบการทำงาน#(my-iterator want-number-of-values),

2. โครงสร้างผลิตภัณฑ์สตริงมัฟฟินMC ส่วนขยายของการแก้ไขตัวแปรตามธรรมชาติซึ่งกำหนดสตริงใด ๆโดยที่ F ฉัน s เป็นตัวอักษรสตริงมัฟฟินMCหรือมัฟฟิน"F1 F2 F3..." MCคำสั่งแมโคร (aka รูปแบบการทำงาน) จะผลิตสตริงมากที่สุดเท่าที่ มอบให้โดยผลิตภัณฑ์สำคัญ (F1) x สำคัญ (F2) x ...

ตัวอย่างเช่นกำหนดตัวแปร xa ที่เก็บ 2 ค่ากล่าวว่า a และ b และ y อีกตัวแปรที่เก็บ 3 ค่าพูดว่า 1 2 3 จากนั้นการประเมินสตริง "x=$(x) y=$(y))"จะสร้างค่าที่แตกต่างกัน 6 ค่า ได้แก่ ลำดับ:

• "x = Ay = 1"
• "x = Ay = 2"
• "x = Ay = 3"
• "x = = 1 โดย"
• "x = โดย = 2"
• "x = = โดย 3"

นี่เป็นหนึ่งในคุณสมบัติที่พึงประสงค์อย่างมากของโครงการมัฟฟินMCถูกออกแบบมาสำหรับ

เรียกใช้!

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

มันทำงานยังไง

อัลกอริทึมของเราขึ้นอยู่กับสิ่งต่อไปนี้:

รับสายไปยัง ascii-art (n), {n = 2p + 1 | p จำนวนเต็ม, p> = 0}, ศิลปะในการสร้างประกอบด้วย n สายอักขระ n ตัว, ซึ่งทั้งสอง, ซ้ายและขวาสุด, ได้รับการแก้ไขและเหมือนกันเสมอ: 'N' สิ่งนี้ช่วยลดปัญหาในการผลิตเฉพาะสายกลาง ตัวอย่างเช่นเมื่อได้รับ n = 5 เราจะสร้างสตริงกลาง 5 ตัวต่อไปแต่ละตัวทำจากอักขระ n-2 (เราได้แทนที่ช่องว่างด้วย '_' เพื่อให้เห็นภาพได้ดีขึ้น):

    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 |
                                _ _ _

• สายกลางดังกล่าวสามารถสร้างได้ง่าย ๆ โดยการวนไปตามลำดับ 4 องค์ประกอบ('_' '_' '_' 'N')ใน 5 กลุ่ม 3; รับ n ใส่ฟังก์ชั่นของลำดับดังกล่าวจะทำ n-2 ตัวอักษรตามด้วยตัวอักษร'_' 'N'การวนซ้ำในลำดับนี้ไม่จำเป็นต้องทำอะไรนอกจากการฝังลำดับภายในมัฟฟินMC I(sequence)ในตัว iterator (ตัววนซ้ำที่วนรอบตลอดลำดับค่าเริ่มต้น)

• จากนั้นเราก็สร้างสตริงตรงกลางความยาว n-2 โดยขอให้ผู้วนซ้ำให้ค่า n-2 ถัดไป (n - 2 ตัวอักษร) ซึ่งต่อกันเข้าด้วยกันเพื่อสร้างสตริงกลางที่คาดหวัง

• สตริงกลาง n ถูกสร้างขึ้นโดยทำซ้ำ n คูณกระบวนการข้างต้นโดยใช้แผนที่เพื่อรวบรวมผลลัพธ์ n (สตริง n ของอักขระ n-2)

• เราใช้อื่นที่มีประสิทธิภาพมัฟฟินMCในตัวสร้างคือผลิตภัณฑ์สตริงเพื่อผลิต n "N#(map...)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.
       )
   ))
  

ภารกิจที่ 3

กำหนดฟังก์ชั่นgcd():

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

gcd()รูปแบบที่สั้นที่สุดของจริง (37 bytes - 2bytes ต้องขอบคุณ Rodolvertice)

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

เรียกใช้!

#(gcd 225 81)

ให้ผลตอบแทน 9

แค่นั้นแหละ.

ขอบคุณสำหรับเกมที่ดีและอาจเป็นไปเพื่อความสนใจของคุณ ภาษานี้มีให้สำหรับผู้ที่ต้องการเล่นใช้หรือขยาย เพียงแค่ขอมันและฉันยินดีที่จะส่งมันมา

ไชโย

Franck

PS การใช้งานปัจจุบันของMuffin MCอยู่ใน Perl5 ซอร์สโค้ดมี Perl 2,000 บรรทัดในปัจจุบันรวมถึงคอมเม้นท์และมาพร้อมกับชุดทดสอบที่ไม่ถดถอยซึ่งเหมาะสำหรับการเรียนรู้การสร้างมัฟฟินMCและการตีความ