Dalam tantangan ini, pengguna akan bergiliran menyelesaikan tiga tugas pengkodean yang cukup sederhana dalam bahasa pemrograman yang dibiarkan semakin tua.

Jawaban pertama harus menggunakan bahasa pemrograman yang dibuat pada tahun 2015. Begitu ada setidaknya satu jawaban dari bahasa 2015, jawaban dapat menggunakan bahasa pemrograman yang dibuat pada tahun 2014. Demikian pula, jawaban yang menggunakan bahasa dari tahun 2013 tidak diperbolehkan sampai ada setidaknya satu jawaban 2014.

Secara umum, penggunaan bahasa pemrograman dari tahun Y tidak diperbolehkan sampai jawaban yang menggunakan bahasa dari tahun Y + 1 telah dikirimkan. Satu-satunya pengecualian adalah Y = 2015.

Menemukan Tahun Bahasa Anda

Untuk menjawab pertanyaan ini, Anda harus tahu tahun "bahasa pemrograman Anda" dibuat. Ini, tentu saja, adalah istilah subjektif; beberapa bahasa dikembangkan selama beberapa tahun, dan banyak bahasa masih ditingkatkan setiap tahun. Biarkan tahun suatu bahasa "dibuat" menjadi tahun pertama implementasi untuk bahasa itu muncul di masyarakat umum.

Sebagai contoh, Python "dibuat pada" 1991 , meskipun pengembangannya telah berlangsung sejak 1989, dan versi 1.0 tidak dirilis sampai 1994.

Jika tahun ini masih subyektif, gunakan akal sehat Anda untuk memilih tahun yang paling tepat. Jangan terjebak dalam sedikit perbedaan pendapat tentang pilihan tahun. Harap berikan tautan ke sumber yang menyebutkan kapan bahasa Anda dibuat.

Versi atau standar yang berbeda dari bahasa pemrograman (misalnya Python 1, 2, 3) dihitung sebagai bahasa yang sama dengan tahun awal yang sama.

Jadi, kecuali tahun bahasa Anda adalah tahun 2015, Anda hanya dapat mengirim jawaban Anda begitu jawaban telah dikirimkan yang tahun bahasanya adalah tahun tepat sebelum Anda.

Jika jawaban yang valid dengan tahun yang sama dengan Anda sudah ada, maka Anda dapat menjawab. Tidak masalah apakah bahasa Anda dikembangkan lebih awal atau lebih lambat pada tahun itu.

Tugas

Anda harus menyelesaikan Tugas 1 hingga 3. Tugas 0 bersifat opsional.

Tugas-tugas ini lebih atau kurang dipilih untuk sesuai dengan tiga aspek penting pemrograman: memberikan output (Tugas 1), pengulangan (Tugas 2), dan rekursi (Tugas 3).

Tugas 0 - Sejarah Bahasa (opsional)

Tulislah setidaknya satu paragraf yang menjelaskan sejarah bahasa pemrograman pilihan Anda: siapa yang mengembangkannya, mengapa, bagaimana, dll. Hal ini terutama didorong jika Anda secara pribadi ada di sekitar ketika bahasa tersebut muncul, dan mungkin bahkan berperan dalam pengembangannya. Jangan ragu untuk mengaitkan anekdot pribadi tentang pengaruh bahasa terhadap Anda atau pekerjaan Anda, atau hal-hal seperti itu.

Jika Anda terlalu muda untuk tahu banyak tentang sejarah bahasa Anda tanpa banyak penelitian, pertimbangkan untuk meninggalkan catatan untuk pengguna yang lebih tua yang mengatakan mereka dapat mengedit posting Anda dan menambahkan beberapa riwayat tangan pertama.

Tugas 1 - "Halo, Dunia!" Varian

Tulis program yang mencetak

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

ke area output standar bahasa Anda (stdout untuk sebagian besar bahasa terbaru).

Misalnya, jika bahasanya adalah Python, hasilnya adalah:

Python was made in 1991!

Tugas 2 - ASCII Seni N

Tulis program yang memungkinkan pengguna memasukkan bilangan bulat ganjil (Anda dapat menganggap bahwa input selalu valid), dan mencetak huruf ASCII art N yang dibuat menggunakan karakter N .

Jika inputnya 1, outputnya adalah:

N

Jika inputnya adalah 3, outputnya adalah:

N N
NNN
N N

Jika inputnya 5, outputnya adalah:

N   N
NN  N
N N N
N  NN
N   N

Jika inputnya 7, outputnya adalah:

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

Polanya berlanjut seperti ini. Output mungkin berisi spasi tambahan.

Tugas 3 - GCD

Tulis sebuah program yang memungkinkan pengguna memasukkan dua bilangan bulat positif (Anda mungkin menganggap input selalu valid), dan mencetak pembagi umum terbesar mereka . Ini didefinisikan sebagai bilangan bulat positif terbesar yang membagi kedua angka tanpa meninggalkan sisanya. Ini dapat dengan mudah dihitung menggunakan algoritma Euclidean .

Contoh:

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

Anda dapat menggunakan fungsi bawaan tetapi coba cari tahu apakah itu ada di versi pertama bahasa Anda. Jika tidak, cobalah untuk tidak menggunakannya.

Aturan

• Anda dapat menjawab beberapa kali, tetapi setiap jawaban baru harus menggunakan bahasa yang dibuat setidaknya 5 tahun sebelum bahasa dalam jawaban terakhir Anda. Jadi, jika Anda menjawab dengan bahasa 2015, Anda tidak bisa menjawab lagi sampai bahasa 2010 diizinkan. Jika Anda mulai dengan jawaban 2010, Anda tidak dapat membuat 2015 menjawab jawaban kedua Anda karena 2015 bukan sebelum 2010.
• Jika memungkinkan, tulis kode Anda sehingga bisa digunakan di versi pertama bahasa Anda (atau versi setua mungkin). (Ini bukan persyaratan karena menemukan kompiler / penerjemah lama untuk beberapa bahasa mungkin sulit.)
• Jangan memposting bahasa yang telah diposkan kecuali jawaban yang diposkan memiliki kesalahan signifikan atau Anda memiliki cara yang sangat berbeda dalam menyelesaikan tugas.
• Golf kode Anda baik-baik saja tetapi tidak diperlukan.
• Baris baru yang tertinggal dalam output dari program apa pun tidak masalah.
• Untuk tugas 2 dan 3, semua nilai input di bawah maksimum yang wajar seperti 2 ¹⁶ harus berfungsi (paling tidak 256).
• Bahasa Anda harus sudah ada sebelum pertanyaan ini diposting.
• Bahasa pemrograman yang sangat lama mungkin memiliki bentuk input dan output yang berbeda dari yang kita pikirkan saat ini. Ini baik Selesaikan tugas dengan kemampuan terbaik Anda dalam konteks bahasa Anda.

Mencetak gol

Skor kiriman Anda adalah:

upvotes - downvotes + (2015 - languageYear) / 2 

Dengan demikian, 0,5 ditambahkan ke penghitungan suara untuk setiap tahun sebelum 2015, memberikan keuntungan untuk bahasa yang lebih tua. Pengajuan dengan skor tertinggi akan menang.

Daftar Jawaban

Cuplikan Stack di bawah ini mencantumkan semua jawaban yang valid sesuai dengan tahun bahasa mereka.

Anda harus memulai posting Anda dengan garis Penurunan harga ini untuk memastikannya terdaftar dengan benar:

#[year] - [language name]

Sebagai contoh:

#1991 - Python

Nama bahasa mungkin ada di tautan (itu akan menjadi tautan yang sama di daftar jawaban):

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

Jawaban yang tidak mengikuti format ini, atau memiliki tahun yang belum diizinkan, atau berasal dari pengguna yang sudah dijawab dalam 5 tahun terakhir ditandai sebagai tidak valid.

<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

Naskah tertulis adalah bahasa yang dibuat pada 2013 oleh Zach Bruggeman. Ini tidak lebih dari pengganti sintaks untuk Javascript untuk membuatnya dibaca seperti monolog internal memetika Shiba Inus.

Halo, Doge

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

Seni 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

Retina adalah bahasa pemrograman berbasis regex, yang saya tulis untuk dapat bersaing dalam tantangan PPCG dengan jawaban hanya-regex, tanpa perlu memanggil regex dalam bahasa host. Retina lengkap-Turing. Untuk membuktikannya, saya telah menerapkan pemecah sistem 2-tag serta Aturan 110 . Itu ditulis dalam C #, karena itu mendukung baik rasa NET. (Secara default) dan rasa ECMAScript (melalui bendera).

Retina dapat beroperasi dalam berbagai mode, tetapi yang paling relevan untuk perhitungan (dan yang menyelesaikan Turing) adalah mode Ganti. Dalam mode Ganti Anda memberi Retina jumlah file sumber yang genap. Ini kemudian dipasangkan, yang pertama dari masing-masing pasangan menjadi regex, dan yang kedua sebagai pengganti. Ini kemudian dieksekusi secara berurutan, memanipulasi input langkah demi langkah. Regex juga dapat didahului oleh konfigurasi (dibatasi dengan `). Opsi paling penting (yang membuat Retina Turing-lengkap) adalah+ , yang membuat Retina menerapkan penggantian dalam satu lingkaran sampai hasilnya berhenti berubah. Dalam contoh berikut, saya juga menggunakan ;, yang menekan output pada tahap menengah.

Di setiap kiriman berikut, setiap baris masuk dalam file sumber terpisah. (Atau, Anda dapat menggunakan -sopsi baru dan meletakkan semua baris ke dalam satu file.) File / baris kosong direpresentasikan sebagai <empty>. File / baris yang mengandung satu ruang direpresentasikan sebagai<space> .

Penjelasannya cukup panjang, jadi saya memindahkannya ke akhir posting.

Program

"Halo Dunia!" Varian

<empty>
Retina was made in 2015!

ASCII Seni N

Ini mengasumsikan bahwa STDIN diakhiri dengan baris baru.

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

Ini mensyaratkan bahwa STDIN tidak diakhiri dengan baris baru.

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

Penjelasan

"Halo Dunia!" Varian

Ini cukup sepele. Tidak memerlukan input (yaitu string kosong), tidak cocok dengan apa pun dan menggantinya dengan Retina was made in 2015!. Satu juga dapat membuatnya bekerja untuk input sewenang-wenang, dengan mengganti pola dengan[\s\S]* misalnya. Itu akan menghirup STDIN dan mengganti semuanya dengan output.

ASCII Seni N

Ini memiliki banyak tahapan. Idenya adalah untuk mengubah input menjadi unary, membuat blok N x N Ndan kemudian "mengukir" dua segitiga. Mari kita melewati setiap tahapan. Ingat bahwa ;hanya menekan output antara, tetapi +menyebabkan penggantian diterapkan dalam satu lingkaran.

;`^
#

Sederhana: tambahkan a #ke input. Ini akan digunakan sebagai penanda dalam konversi ke 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#

Ini mengubah satu digit menjadi unary. Dibutuhkan digit yang sudah dikonversi (\d*)dan ulangi 10 kali. Dan kemudian mengambil digit berikutnya dan menambahkan jumlah digit yang sesuai. Nilai aktual dari digit tidak relevan pada tahap ini. Ketika #mencapai akhir angka, regex tidak lagi cocok, dan konversi selesai. Sebagai contoh, nomor 127tersebut akan diproses sebagai

#127
1#27
111111111122#7
1111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111227777777#

di mana baris terakhir berisi tepat 127 digit karakter.

;`#
<empty>
;`\d
N

Dua tahap sederhana yang menyingkirkan itu #dan kemudian mengkonversi semua digit N. Berikut ini saya akan menggunakan input 7sebagai contoh. Jadi sekarang kita punya

NNNNNNN

Tahap selanjutnya

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

mengganti masing N- masing dengan seluruh string (ingat bahwa itu berisi baris baru), dan juga menghapus baris baru itu sendiri. Karenanya, ini mengubah baris tunggal menjadi kotak persegi:

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN

Sekarang segitiga atas. Pertama, kita memulai sesuatu dengan mengubah N di sudut kanan bawah menjadi spasi:

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

Lookahead memastikan bahwa kami memodifikasi yang benar N. Ini memberi

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNN N
NNNNNNN
NNNNNNN

Dan sekarang

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

adalah regex yang cocok dengan Nyang di atas atau di sudut kiri atas karakter spasi, dan menggantinya dengan spasi. Karena penggantian itu diulangi, ini pada dasarnya adalah genangan banjir, yang mengubah oktan ke-3 dari ruang awal menjadi lebih banyak ruang:

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

Dan akhirnya, kami mengulangi hal yang sama dengan segitiga bawah, tetapi kami menggunakan karakter yang berbeda, sehingga ruang yang sudah ada tidak menyebabkan isi banjir yang salah:

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

set benih:

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

Kemudian

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

mengisi banjir.

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

Dan akhirnya

S
<space>

Mengubahnya Smenjadi spasi dan kita selesai:

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

GCD

GCD di unary sebenarnya sangat sepele dengan regex. Sebagian besar dari ini terdiri dari konversi desimal ke unaris dan unary ke desimal. Ini bisa dilakukan lebih kompak, tetapi ini bukan kode golf, jadi ...

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

Tahap-tahap ini pada dasarnya sama dengan di atas, kecuali bahwa kedua nomor input dikonversi, dan hasilnya menggunakan 1s bukannya Ns (bukan itu penting). Jadi jika inputnya adalah 18 24, maka ini akan menghasilkan

111111111111111111 111111111111111111111111

Sekarang

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

adalah seluruh perhitungan GCD. Kami mencocokkan pembagi umum dengan menangkap sejumlah 1s, dan kemudian menggunakan referensi kembali untuk memastikan bahwa kedua angka dapat ditulis dengan mengulangi string itu (dan tidak ada yang lain). Karena cara backtracking bekerja di mesin regex (yaitu yang .+serakah), ini akan selalu menghasilkan yang terbaik pembagi umum secara otomatis. Karena pertandingan mencakup seluruh string, kami cukup menulis kembali grup penangkap pertama untuk mendapatkan GCD kami.

Akhirnya, konversi unary ke desimal ...

;`$
#:0123456789

Tambahkan penanda #, pembatas :dan semua digit ke string. Ini perlu, karena Anda tidak dapat menghasilkan karakter baru secara kondisional dalam penggantian regex. Jika Anda ingin penggantian bersyarat, Anda perlu menarik karakter dari string itu sendiri, jadi kami menempatkannya di sana.

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

Ini adalah kebalikan dari ekspansi unary sebelumnya. Kami menemukan kelipatan 10 terbesar yang cocok dengan string saat ini. Kemudian kita memilih digit berikutnya berdasarkan sisanya, dan membaginya dengan 10, sambil memindahkan marker melalui digit.

#|:.*
<empty>

Dan terakhir hanya langkah pembersihan untuk menghilangkan marker, pembatas, dan digit helper.

2013 - Snap !

Jepret ! adalah bahasa berdasarkan Scratch , dibuat di Universitas Berkeley. Ini merupakan pemutakhiran untuk Scratch yang menampilkan data kelas satu dan blok khusus (fungsi). Seperti Scratch, ini bukan berbasis teks, melainkan dilakukan oleh "blok" visual yang saling berhubungan.

Jepret ! , yang ditulis dalam JavaScript, adalah penerus BYOB, yang ditulis dalam Squeak Smalltalk. Jepret ! beta dirilis untuk konsumsi publik pada Maret 2013 .

Jepret ! sebenarnya bukan bahasa esoterik. Ini digunakan sebagai bahasa pemrograman untuk Beauty and Joy of Computing (BJC) kursus CS CS di Berkeley dan lainnya.

Saya membantu dengan pengujian dan sebagainya.

Varian "Hello World"

Seni ASCII "N"

Ini menggunakan stdlib untuk beberapa blok.

Perulangan yang cukup mendasar di sini. Mengambil input. Kemudian kita tambahkan semuanya dan katakan (hasil untuk n = 5):

Saya mengambil kebebasan di sini untuk hanya menggunakan 2 spasi alih-alih 1, karena Snap! tidak mengatakan hal-hal di luar angkasa.

GCD

Algoritma Euclidean tidak terlalu cepat, tetapi berfungsi, dan cukup sederhana. (Maaf, saya membuat kesalahan ketik pada nama blokir. Sekarang saya menutup tab tanpa menyimpan. Ini harus tetap tinggal.)

Definisi fungsi ini kemudian akan menghasilkan blok ini:

2007 - LOLCODE

Sejarah Bahasa

LOLCODE dibuat pada 2007 oleh Adam Lindsay, seorang peneliti di Lancaster University. Sintaksisnya didasarkan pada meme lolcat yang dipopulerkan oleh Cheezburger, Inc.

"Halo Dunia!" Varian

HAI
VISIBLE "LOLCODE wuz maed in 2007!"
KTHXBYE

ASCII Seni 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

Nilai dibaca sebagai string (BENANG) dari stdin menggunakan GIMMEH. Mereka dapat dikonversi menjadi numerik (NUMBR) dengan mengalikannya dengan 1.

Nilai dicetak ke stdout menggunakan VISIBLE. Secara default, baris baru ditambahkan, tetapi dapat ditekan dengan menambahkan tanda seru.

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 melakukan penggabungan string.

1982 - PostScript

PostScript adalah bahasa untuk membuat grafik dan pencetakan vektor.

Adobe didirikan pada tahun 1982, dan produk pertama mereka adalah PostScript. Bahasa itu digunakan dalam printer: perintah ditafsirkan oleh printer untuk membuat gambar raster, yang kemudian dicetak ke halaman. Itu adalah komponen yang sangat umum dari printer laser hingga 1990-an. Tapi itu jelas cukup intensif CPU pada printer, dan ketika prosesor komputer menjadi lebih kuat, lebih masuk akal untuk melakukan rasterisasi pada komputer daripada printer. PostScript sebagian besar sudah hilang pada printer konsumen, meskipun masih ada pada banyak printer high-end.

Standar yang menggantikan PostScript adalah format yang sedikit dikenal yang disebut PDF.

PostScript telah keluar dari mode pada saat saya mulai pemrograman, tetapi saya belajar sedikit ketika saya masih di universitas sebagai cara lain untuk membuat dokumen untuk TeX. Itu sangat berbeda dengan bahasa pemrograman lain yang pernah saya gunakan (notasi terbalik, susun, cetak ke halaman, bukan konsol), tapi itu menyenangkan untuk menghapus bahasa lama ini untuk bersenang-senang.

Karena PostScript adalah bahasa cetak, tampaknya lebih tepat untuk menggunakannya untuk mencetak sesuatu kemudian mengirim output ke konsol.

Tugas 1

/Courier findfont
12 scalefont
setfont
newpath

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

Beberapa baris pertama mengatur kanvas untuk menggambar. Kemudian movetoperintah memberi tahu PS untuk menggambar pada posisi tertentu, dan showmencetak string ke halaman. Perhatikan bahwa tanda kurung menandai sebuah string dalam PostScript, bukan tanda kutip.

Tugas 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

Saya menulis sebuah fungsi untuk menggambar "ASCII art" N, tetapi tidak ada cara bagi fungsi PostScript untuk mengambil argumen. Sebagai gantinya, Anda mendorong argumen Anda ke tumpukan, lalu mendapatkannya kembali. Itu adalah/x exch def intinya.

Contoh: misalkan tumpukan itu 8 9 2. Pertama kita dorong nama /xke tumpukan, jadi tumpukan itu 8 9 2 /x. The exchOperator swap dua nilai stack, jadi sekarang tumpukan 8 9 /x 2. Lalu defmuncul dua nilai tumpukan teratas, dan tentukan /xuntuk memiliki nilai tersebut 2. Tumpukan sekarang 8 9.

Ketika saya mulai menggunakan PostScript, saya menemukan ini sedikit membingungkan. Saya telah membaca tentang tumpukan sebagai konsep teoretis, tetapi ini adalah pertama kalinya saya menggunakannya dalam praktik.

Sisa dari fungsi ini adalah beberapa kode gambar: mulai dari sudut kanan bawah, mengisi baris sekaligus dari kiri-ke-kanan-ke-diagonal.

Tugas 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

Sekali lagi, saya menggunakan bentuk algoritma Euclid, tetapi saya lupa bahwa PostScript memiliki operator modulo bawaan, jadi saya harus menulis sendiri. Ini ternyata menjadi pengingat yang berguna tentang kendala pemrograman berbasis stack. Implementasi pertama saya modulodidasarkan pada rekursi:

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

yang bagus sampai Anda mencoba menjalankan ini ketika xbesar dan ykecil (mis. 5689 dan 2). Anda hanya dapat memiliki hingga 250 elemen pada tumpukan, dan saya meniup melebihi batas tumpukan. Ups. Saya harus kembali ke papan gambar untuk yang itu.

Kode GCD itu sendiri cukup sederhana. Tapi sama seperti fungsi tidak bisa mengambil argumen, jadi mereka tidak memiliki nilai balik. Sebagai gantinya, Anda harus mendorong hasilnya ke tumpukan di mana orang lain dapat mematikannya nanti. Itulah yang adanb a gcd baris: ketika mereka selesai mengevaluasi, mereka mendorong nilai ke tumpukan.

Jika Anda memasukkan semua kode dalam dokumen dan mencetaknya, seperti inilah hasilnya:

2009 - > <>

Terinspirasi oleh Befunge,> <> (Fish) adalah bahasa 2D berbasis stack esoterik, yaitu aliran program bisa naik, turun, kiri atau kanan. Versi awal> <> menampilkan multithreading di mana [dan] membuat dan mengakhiri utas, tetapi untuk alasan kesederhanaan petunjuk ini diubah untuk membuat dan menghapus tumpukan baru masing-masing.

Penerjemah resmi saat ini untuk> <> dapat ditemukan di sini . Sayangnya, tautan ke interpreter lama di Esolang wiki rusak.

"Halo Dunia!" Varian

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

Perhatikan bagaimana string ditulis mundur -> <> secara teknis tidak memiliki string, dengan satu-satunya tipe data yang merupakan campuran aneh char, int dan float. "matikan string parsing, mendorong masing-masing karakter ke tumpukan sampai penutupan "bertemu.

Bagian kedua dari kode kemudian mendorong panjang stack l, memeriksa apakah itu nol ?!dan jika demikian program berakhir ;. Kalau tidak, penunjuk instruksi berlanjut, mengeluarkan bagian atas tumpukan dengan osebelum mengeksekusibb+0. , yang akan memindahkan penunjuk ke posisi (22, 0)tepat sebeluml , menciptakan satu lingkaran.

ASCII Seni N

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

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

   \                                                         <   /

Dengan spasi untuk kejelasan. Anda dapat mencobanya di penerjemah online baru di sini dan melihat penunjuk instruksi berputar-putar - ingatlah untuk memasukkan nomor di kotak teks "Tumpukan Awal". Jika Anda menjalankan melalui juru bahasa Python, gunakan -vbendera untuk menginisialisasi tumpukan, misalnya

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

Untuk program ini, kami memasukkan input nke register &dan menekan 0, yang akan kami sebut i"iterations". Sisa dari program ini adalah loop raksasa yang berlangsung seperti ini:

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

Lalu kami mengulangi loop dari awal.

Panah ^>v<mengubah arah aliran program dan cermin /\mencerminkan arah aliran program.

GCD

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

Berikut ini contoh dari apa yang terlihat seperti program golf>>. Sekali lagi, Anda dapat mencoba ini dalam juru bahasa online (masukkan dua nilai yang dipisahkan koma, dalam kotak "Tumpukan awal", misalnya 111, 87) atau dengan menggunakan -vbendera juru bahasa Python, misalnya

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

Program ini menggunakan algoritma Euclidean. Inilah GIF yang saya siapkan sebelumnya:

Perhatikan bahwa> <> adalah toroidal, jadi ketika bagian kiri bawah v instruksi dijalankan, penunjuk instruksi akan turun, membungkus, dan muncul kembali di atas.

Sunting: Dengan membuat kode sepenuhnya berjalan dari kanan ke kiri , @randomra berhasil mencukur tiga byte dengan

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

Kira saya tidak cukup golf :)

2012 - Elemen

Ini adalah bahasa yang saya ciptakan pada awal 2012 untuk menjadi bahasa golf yang sederhana. Maksud saya, ada sedikit atau tidak ada kelebihan operator. Operator juga lebih sederhana dan lebih sedikit jumlahnya daripada kebanyakan bahasa golf modern.

Fitur yang paling menarik dari bahasa ini adalah struktur datanya. Ada dua tumpukan dan hash yang digunakan untuk menyimpan informasi.

M-stack adalah tumpukan utama, di mana aritmatika dan sebagian besar operasi lainnya berlangsung. Ketika data dimasukkan atau dicetak, ini adalah tempat ia diambil atau diambil.

C-stack adalah tumpukan kontrol. Di sinilah aritmatika boolean berlangsung. Nilai-nilai teratas dari c-stack digunakan oleh If and While loop sebagai kondisinya.

Hash adalah tempat variabel disimpan. Itu; dan~ menyimpan dan mengambil data dari hash, masing-masing.

Elemen adalah bahasa yang diketik dengan sangat lemah. Ini menggunakan kemampuan Perl untuk secara bebas menafsirkan angka sebagai string dan sebaliknya.

Sementara saya melakukannya, saya mungkin juga menyertakan semua dokumentasi untuk bahasa tersebut. Anda dapat menemukan penerjemah asli 2012, yang ditulis dalam Perl, di sini . Pembaruan: Saya telah membuat versi yang lebih bermanfaat, yang dapat Anda temukan di sini .

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 \

Tugas 1 - Cetak Teks

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

Salah satu bagian yang lebih canggung dari bahasa ini adalah tidak adanya pembatas string, oleh karena itu diperlukan karakter pelarian dalam string ini. Itu` pada akhirnya mencetak string.

Tugas 2 - ASCII Seni N

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

Di sini, Anda akan menyaksikan beberapa manipulasi tumpukan. Untuk membuat penjelasan sedikit lebih mudah diformat, saya akan mengganti baris baru dengan Ldan spasi dengan 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

Setelah melakukan beberapa golf ekstrim dari jawaban ini, saya menemukan solusi 39 byte, walaupun jauh lebih rumit.

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

Tugas 3 - GCD

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

Ini adalah metode berbasis tumpukan.

__                 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

Sejarah Bahasa

Julia dikembangkan pada 2012 oleh Jeff Bezanson, Stefan Karpinski, dan Viral Shah sementara Jeff adalah seorang mahasiswa di Institut Teknologi Massachussets (MIT), disarankan oleh profesor Alan Edelman. Mereka termotivasi oleh keinginan untuk bahasa pemrograman yang bersifat open source, cepat, dan dinamis (di antara banyak hal lain) sambil mempertahankan kemudahan penggunaan dalam berbagai aplikasi. Produknya adalah Julia, pendekatan baru untuk komputasi ilmiah berkinerja tinggi.

"Halo Dunia!" Varian

println("Julia was made in 2012!")

Mencetak ke STDOUT di Julia cukup sederhana!

ASCII Seni 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

Kode ini indentasi agar mudah dibaca, tetapi Julia tidak memberlakukan batasan pada spasi putih.

GCD

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

Hal terakhir yang tercantum dalam fungsi dikembalikan secara implisit.

1988 - Mathematica

Atau haruskah saya menyebutnya Bahasa Wolfram ?

Tugas 0

Pencipta Mathematica adalah Stephen Wolfram, Pendiri dan CEO Wolfram Research. Sebelum perkembangan Mathematica, dia adalah seorang ahli fisika. Ada sejumlah besar perhitungan aljabar dalam fisika, jadi dia menjadi pengguna Macsyma .

Wolfram mendapatkan PHD-nya pada tahun 1979, ketika dia berusia 20 tahun. Dia berpikir bahwa dia membutuhkan CAS yang lebih baik daripada Macsyma untuk melakukan fisika, jadi dia mulai menulis SMP ("Program Manipulasi Simbolik"). Versi pertama SMP dirilis pada tahun 1981. SMP adalah pendahulu dari Mathematica. Meskipun memiliki pengaruh yang mendalam pada Mathematica, tidak ada kode yang pernah digunakan untuk Mathematica.

Pada tahun 1986, Wolfram memutuskan untuk menulis "sistem perhitungan ultimat". Dia mulai menulis kode pada tahun 1986, dan mendirikan Wolfram Research pada tahun 1987. Akhirnya, Mathematica 1.0 dirilis pada 23 Juni 1988.

Saya tidak menemukan Mathematica 1.0. Faktanya, Mathematica 1.0 tidak memiliki versi Windows atau Linux. Tetapi saya menemukan Mathematica 2.0 di situs web Tiongkok. Itu masih bisa dijalankan di Windows XP.

Tugas 1

Print["Mathematica was made in 1988!"]

Atau sederhananya:

"Mathematica was made in 1988!"

Tugas 2

Dalam Mathematica hari ini, kita dapat menulis:

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

Sama seperti Julia dan R , ini adalah solusi matriks. Dalam Mathematica, Anda dapat menentukan matriks jarang menggunakan pencocokan pola.

Namun, SparseArraydiperkenalkan di Mathematica 5.0, jadi kami tidak dapat menggunakannya di Mathematica 1.0.

Berikut ini solusi yang berfungsi di 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];
]

Kami tidak dapat menulis f[i_, 1 | i_ | n] = "N"karena Alternativesdiperkenalkan di Mathematica 2.0.

Tugas 3

Kami hanya dapat menggunakan fungsi bawaan:

gcd = GCD

Atau kita dapat menggunakan definisi GCD:

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

Atau kita dapat menggunakan LCM , meskipun lebih umum LCM dihitung dari GCD:

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

Atau kita dapat menggunakan algoritma Euclidean dengan pencocokan pola:

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

Atau sebagai fungsi anonim:

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

Semua fungsi di atas diperkenalkan di Mathematica 1.0.

1999 - XSLT

The World Wide Web Consortium (W3C) dibuat XSLT untuk mengubah XML menjadi HTML, teks, dll Contoh berikut mengasumsikan masukan tertutup dalam <input>..</input>tag.

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

Yang ini sederhana. Cocok denganinput tag di tingkat atas dan menggantinya dengan output yang diinginkan.

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

Yang ini mendefinisikan 2 templat rekursif, loopdan spaces. loopdengan parameter idan nakan menghasilkan output yang diinginkan n, mulai dari posisi i. spacesdengan parameter nakan menghasilkann spasi.

Tugas 3

Masukan untuk ini harus dalam <input><num>..</num><num>..</num></input>tag.

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

Yang ini hanyalah templat rekursif gcdyang menggunakan algoritma Euclidean.

2014 - CJam

CJam dibuat oleh pengguna aditsu PPCG dan dirilis sekitar April 2014 .

"Halo Dunia!" Varian

"CJam was made in 2014!"

CJam secara otomatis mencetak isi tumpukan di akhir program

ASCII Seni N

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

Penjelasan kode:

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

Mengambil tinggi / lebar N sebagai input melalui STDIN. Cobalah online di sini

GCD

l~{_@\%}h;

Mengambil dua angka sebagai input melalui STDIN. Cobalah online di sini

1990 - Haskell

Haskell adalah bahasa fungsional murni yang populer (atau harus saya katakan: paling populer ?). Itu menonjol dari arus utama dengan model evaluasi yang tidak biasa (secara default, semuanya malas atau, secara teknis, tidak ketat) dan oleh sistem tipe berbasis Hindley-Milner yang, bahkan sekarang, masih di antara yang paling kuat di luar sana.

Tugas 1

main = putStrLn "Haskell was made in 1990!"

Tugas 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

Demo, cetak seluruh daftar tanpa batas (hingga pengguna batal, atau dunia berakhir ...)

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

...

Tentu saja, Anda dapat dengan mudah mencapai salah satu dari ini, dengan mengakses hanya satu elemen dari daftar tak terbatas:

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

Tugas 3

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

1972 - INTERCAL

Dan Anda pikir Fortran dan Cobol aneh. Ini gila!

Tugas 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

Saya tidak akan mencoba menjelaskan sistem input dan output INTERCAL; Bacalah ini dan berharap kamu tidak mati.

Tugas 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

Aduh, masya Allah.Saya butuh sedikit waktu untuk mencari tahu. Nomor labelnya berantakan dan karenanya mencerminkan hal itu. Saya tidak akan mencoba menjelaskan ini kecuali ada yang bertanya.

Tugas 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

Ini agak sederhana. Karena ... keanehan INTERCAL, Anda harus memasukkan angka seperti ini:

THREE FIVE

Misalnya, untuk mendapatkan GCD 42 dan 16, saya akan memasukkan:

FOUR TWO
ONE SIX

Ini juga mencetak angka dalam angka Romawi ... karena itu INTERCAL untuk Anda!

1967 - APL

Pada tahun 1957, di Universitas Harvard, Ken Iverson mulai mengembangkan notasi matematika untuk manipulasi array. Selama 1960-an, notasinya dikembangkan menjadi bahasa pemrograman di IBM. Implementasi parsial pertama dibuat pada tahun 1963, dan bahkan digunakan di sekolah menengah untuk mengajar siswa tentang fungsi transendental. Implementasi yang lengkap dan dapat digunakan harus menunggu hingga 1965. Selama dua tahun itu hanya digunakan secara internal oleh IBM. Pada tahun 1967, IBM merilis kepada publik juru bahasa APL yang dijalankan pada komputer IBM 1130, yang telah selesai pada tahun 1966. Anda dapat memahami betapa sulitnya memilih tahun untuk itu, namun, saya pikir itu seharusnya tahun 1967, karena ini adalah tahun pertama implementasi penuh tersedia untuk umum. Jika ada yang benar-benar tidak setuju, saya bisa mengubahnya.

Kode sumber untuk APL \ 360, sedang online , seperti halnya sebuah emulator. Inilah yang saya gunakan untuk menguji contoh-contoh ini. Berasal dari tahun 1967, dan bersama dengan APL \ 1130 (untuk IBM 1130 yang disebutkan di atas) ini lebih atau kurang asli. Seperti yang diharapkan, ini sangat primitif. Tidak memiliki dukungan untuk basa-basi seperti huruf kecil, setiap operator hanya bekerja dengan fungsi builtin, dan set fungsi builtin sangat jarang (khususnya, ∨adalah hanya or , dan tidak tidak ganda sebagai gcd). Deskripsi asli dan lengkap tersedia di sini , namun, saya perhatikan bahwa versi yang saya miliki bahkan tidak lengkap sehubungan dengan dokumen itu, kurang⍎ antara lain.

Saya telah menyediakan program-program baik dalam format Unicode (sehingga Anda dapat membacanya), dan dalam pengkodean asli (sehingga Anda dapat memotong dan menempelkannya ke jendela APL emulator).

Luar biasanya, program-program ini berjalan dengan benar tanpa ada perubahan (kecuali untuk pengkodean) dalam versi modern Dyalog, NARS2000, dan GNU APL. Jadi saya kira saya sudah menemukan cara untuk menulis APL portabel: hanya berpura-pura 1967!

Tugas 1:

Unicode:

⎕←'APL WAS MADE IN 1967!'

APL \ 360:

L[Kapl was made in 1967ÝK

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

Tugas 3:

Saya telah memecahkan ini dengan cara rekursif standar. Secara teori, Anda bisa melakukan sesuatu yang pintar dan berorientasi pada array, seperti jawaban J; dalam praktiknya, bagaimanapun, yang memiliki penggunaan memori O (N) dan dengan cepat menguasai perangkat keras dan perangkat lunak era 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

Menunggu lebih dari sehari untuk mengisi tahun 1996, jadi saya bisa mengisi Ruby. Nah kenapa tidak belajar OCaml kalau begitu, sepertinya mirip dengan haskell ...

Halo Dunia

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

String yang bisa berubah!

GCD

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

Tidak ==dan infix mod, itu lucu

2005 - Pendahuluan

Prelude adalah bahasa yang sangat menyenangkan, yang kode sumbernya terdiri dari beberapa "suara" yang dieksekusi secara paralel dan yang saya sangat menikmati memecahkan masalah di . Ini dimaksudkan untuk menjadi representasi ASCII dari bahasa saudara Fugue , yang benar-benar mengambil file .midi sebagai kode sumbernya dan mengkodekan instruksi yang ditemukan dalam Prelude sebagai interval dalam melodi suara-suara.

Prelude cukup minimalis, namun Turing lengkap (asalkan Anda menggunakan setidaknya 2 suara). Seperti yang saya katakan, suara-suara (baris kode) dieksekusi secara bersamaan, kolom demi kolom. Setiap suara beroperasi pada tumpukannya sendiri, yang diinisialisasi ke angka nol tanpa batas. Prelude mendukung instruksi berikut:

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

Beberapa catatan tambahan:

• Suara-suara itu adalah siklik, jadi ^ di bagian atas salinan suara dari suara bawah (dan sebaliknya).
• Banyak ?dan! dalam kolom yang sama dieksekusi dari atas ke bawah.
• Sesuai spesifikasi bahasa , ?dan !membaca dan menulis karakter dengan kode karakter yang sesuai. Namun, juru bahasa Python juga memiliki saklar dalam kodenya untuk mencetak angka sendiri. Untuk tujuan pengujian saya sebenarnya menggunakan versi modifikasi yang juga dapat membaca angka, bukan karakter. Tetapi konsensus di sekitar sini adalah bahwa input / output numerik sebenarnya dapat diberikan sebagai nilai byte, maka modifikasi ini tidak diperlukan untuk membuat program yang valid berurusan dengan angka.
• Cocok (dan )tidak harus dengan suara yang sama. Suara yang digunakan untuk kondisi selalu yang (muncul. Oleh karena itu, posisi vertikal) sama sekali tidak relevan.
• Karena sifat eksekusi simultan Prelude, setiap instruksi dalam kolom yang sama dengan a (dieksekusi hanya sekali sebelum loop dimulai, dan terlepas dari apakah loop dimasukkan. Demikian pula, setiap instruksi dalam kolom yang sama dengan a )dieksekusi pada akhir setiap iterasi, terlepas dari apakah loop akan keluar setelah iterasi ini.

Pertama-tama saya akan menunjukkan kepada Anda tiga program tanpa banyak komentar. Anda dapat menemukan penjelasan lengkap di bawah ini.

Program

"Halo Dunia!" Varian

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

Jika Anda menggunakan juru bahasa Python, pastikan itu NUMERIC_OUTPUT = False .

ASCII Seni 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#

Untuk kemudahan penggunaan, program ini mendapat manfaat dari membaca input sebagai angka, tetapi output tidak boleh berupa angka. Jadi jika Anda menggunakan interpreter Python yang dimodifikasi, atur

NUMERIC_INPUT = True
NUMERIC_OUTPUT = False

GCD

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

Ini paling baik digunakan dengan semua input / output numerik yaitu

NUMERIC_INPUT = True
NUMERIC_OUTPUT = True

Penjelasan

"Halo Dunia!" Varian

Ini cukup mudah. Saya menggunakan 3 suara untuk menghasilkan kode karakter untuk semua karakter secara berurutan Prelude was made in 2005!. Saya mulai dengan komputasi 8 + 9*8 = 80, yang merupakan kode karakter P:

 9(1-)
 8 8+

Setelah itu saya kebanyakan hanya menyalin kode karakter sebelumnya dan menambah atau mengurangi perbedaan ke yang berikutnya. Berikut adalah kode, tetapi masing-masing !diganti dengan karakter yang sedang dicetak (dan _untuk spasi dan %untuk digit):

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

Final 55+!mencetak baris baru, hanya karena lebih bagus.

Sebagai catatan, jumlah suara cukup sewenang-wenang untuk tugas ini, tetapi 3 cukup nyaman karena jumlah terbesar di mana setiap suara dapat secara langsung mengakses satu sama lain suara.

ASCII Seni 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#

Dengan 5 suara, ini jelas merupakan salah satu program paling kompleks yang saya tulis sejauh ini. Suara-suara secara kasar memiliki tujuan sebagai berikut:

1. Hanya suara pembantu yang menyimpan N-1untuk digunakan di loop dalam.
2. Ini adalah semacam suara "utama", yang bertuliskan input, berisi saklar penting dan juga berisi loop luar (yaitu yang melewati baris).
3. Ini menyimpan 32ruang cetak yang nyaman.
4. Ini berisi loop dalam (yang di atas kolom).
5. Ini menyimpan 78untuk mencetak dengan mudah N.

Mari kita melalui bagian kode bagian demi bagian. Pertama, saya membuat 32as -4 + 9*4dan 78as 6 + 9*8:

9(1-)
4-4+

6 8+

Sekarang saya sedang mencetak satu N(karena kita selalu membutuhkan satu) saat membaca input Ndan menyimpan N-1dan N-2dalam dua suara pertama:

      v2-
     ?1-

     v!

Selanjutnya, ada "loop" dikondisikan N-1. Pada akhir loop, suara kedua selalu dikurangi menjadi 0, dan loop keluar setelah iterasi pertama. Jadi intinya, ini saja if(N > 1){...}. Setelah loop kami mencetak satu baris baru. Untuk rekap, kami sekarang memiliki kerangka kerja berikut:

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

Di dalam kondisi ini, kita N-2spasi pertama dan satu Nuntuk menyelesaikan baris pertama, dan kita juga menyimpan N-1suara pertama untuk digunakan di masa depan:

         (1-)v         
          v!  

             v!

Sekarang daging kode yang sebenarnya. Pertama, ada loop luar, yang mencetak N-1baris. Untuk setiap baris, pertama-tama kita mencetak baris baru, dan sebuah N. Kemudian kita mengulang N-2kali, mencetak spasi atau Ns (lebih lanjut tentang itu nanti). Dan akhirnya kami mencetak lagi N:

               1-55+!  

                v1-v!(               )v!
               v#

Akhirnya, bagian yang menyenangkan: mencetak setiap baris (dan mendapatkan posisi yang Nbenar). Sebenarnya tidak ada if / else di Prelude, jadi saya harus membuatnya sendiri menggunakan dua loop pada suara yang berbeda. Kondisi ini dapat dengan mudah diperoleh dengan mengurangi variabel loop dalam dan luar - kita dapatkan 0jika kita ingin mencetak Ndan sesuatu yang tidak nol jika kita ingin mencetak spasi.

Gagasan dasar dari if / else di Prelude adalah menempatkan loop setelah nilai yang relevan - kode "jika" (atau bukan nol), dan segera keluar dengan menekan a 0. Di suara lain, Anda menyimpan nilai yang tidak nol, dan loop lain setelah loop "jika". Selama loop "jika" Anda meletakkan nol di atas suara lain itu, untuk mencegah eksekusi "lain". Ada beberapa fleksibilitas dalam apakah Anda mendorong nilai nol di atas nilai bukan nol atau hanya membuang nilai bukan nol jika ada nol di bawahnya, tetapi ini adalah ide umum. Anda mungkin juga harus melakukan pembersihan setelah itu, jika Anda ingin tetap menggunakan suara yang relevan. Seperti apa kode ini:

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

Dan itu dia!

GCD

Ini "hanya" implementasi berulang dari algoritma Euclidean. Tetapi modulo di Prelude agak mengganggu, sebagian besar karena Anda tidak dapat dengan mudah memeriksa apakah suatu angka positif atau negatif. Kode ini memanfaatkan implementasi signum yang saya tulis beberapa waktu lalu . Yaitu sebagian besar kode hanya mengubah angka menjadi -1, 0atau 1. Ini kemudian dapat dengan mudah diubah menjadi kondisi untuk angka positif atau negatif dengan menambahkan atau mengurangi 1.

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

Jadi kita punya empat suara saat ini. Suara pertama hanya melacak bdan berisi kondisi terminasi utama (yaitu loop keluar saat bmenjadi 0). Suara kedua berisi adan dengan bantuan suara tiga dan empat menghitung a % b, sebelum menukar hasilnya dengan yang sebelumnya b. Akhirnya, !dicetak akapan b == 0.

Mari kita lihat bagian signum terlebih dahulu:

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

Nomor input nditemukan pada suara pertama (suara kedua dalam program lengkap). Hasilnya akan berakhir di suara bawah. Dua suara lainnya diharapkan kosong (yaitu diisi dengan nol). Perhatikan bahwa, jika n == 0, maka kedua loop dilewati dan suara bawah masih berisi 0, hanya apa yang kita inginkan.

Jika n bukan nol, loop kecil pertama dimasukkan. Kami mendorong nol untuk segera keluar, menempatkan dua salinan nke suara tengah dan 1ke suara bawah. Sekarang ide dasarnya adalah untuk menambah satu salinan nsementara mengurangi salinan lainnya nhingga salah satu dari mereka mencapai nol. Saat melakukan hal itu, suara 1di bagian bawah membalik tandanya sepanjang waktu (yang mudah dilakukan dengan mengurangkannya dari 0bawahnya di tumpukan). Ini diatur sedemikian rupa sehingga ketika salah satu angka mencapai nol, suara bawah akan berisi tanda yang benar.

Sekarang modulo diimplementasikan dengan mengurangi bdari ahingga hasilnya negatif. Ketika itu terjadi, kami menambahkan satu blagi. Itu sedikit ini:

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

Perhatikan konstruksi if / else di bagian bawah, yang mirip dengan yang saya gunakan untuk Tugas 2.

2007 - Gores

Menggaruk adalah bahasa yang dibuat oleh MIT untuk tujuan pendidikan. Saya sudah sangat terlibat dengannya selama 5 tahun; lebih lanjut tentang itu nanti.

Semua ini dapat dilihat di sini .

Saya sangat terburu-buru sekarang dan akan menjelaskan potongan nanti. Semoga mereka cukup jelas.

Tugas 1

Tugas 2

Tugas 3

1972 - C

Kita semua tahu tentang C, bukan? C dibuat di Bell Labs, bersama dengan Unix. Unix sebagian besar ditulis dalam C. Semua turunan modern Unix sebagian besar masih ditulis dalam sintaksis C. C telah mempengaruhi banyak, banyak bahasa pemrograman. Mungkin bahasa pemrograman tertua yang masih digunakan secara luas untuk pengembangan baru.

C sendiri adalah turunan dari B, yang saya harap akan berakhir di daftar ini juga. Tidak ada bahasa pemrograman 'A': B adalah varian dari BCPL, yang pada gilirannya adalah CPL yang dipreteli. Tidak satu pun dari bahasa ini yang sangat populer. Namun, BCPL adalah bahasa tempat program "Hello World" pertama kali ditulis. Fakta lain yang menarik adalah bahwa B memiliki keduanya /* */dan //komentar, tetapi C menjatuhkan //komentar. Mereka kemudian diperkenalkan kembali ke C dengan standar C99.

Program C di sini diuji dengan kompiler Unix V5 C, dari tahun 1974. Ini adalah kompiler C tertua yang dapat saya temukan dan mulai bekerja, dan program ini tidak akan dikompilasi pada kompiler C modern. (Salah satu perubahan yang dibuat adalah bahwa operator mutasi seperti +=dulu ditulis=+ .)

#include <... >belum ada. Perpustakaan standar juga tidak banyak. Saya harus menulis sendiri atoi. Saya membaca beberapa kode sumber V5 untuk mencari tahu hal-hal mana yang diperbolehkan dan mana yang tidak. Versi yang saya gunakan adalah yang pertama untuk memasukkan structs, tetapi karena saya tidak menggunakan itu, dan sintaks tampaknya tidak banyak berubah sampai V7 (seperti K&R C), ini mungkin bekerja dengan versi sebelumnya juga.

Saya telah melakukan yang terbaik untuk menulis kode saya dengan gaya yang sama dengan menggunakan kode sumber V5. (Bukan berarti itu sangat konsisten.)

Lihat di sini untuk tautan ke Unix V5, sebuah emulator, dan instruksi untuk menjalankannya di komputer modern.

Tugas 1

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

Tugas 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]));
}

Tugas 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 adalah bahasa fungsional murni yang diketik secara dependen, yang menekankan bahwa pada kenyataannya praktis dapat digunakan untuk aplikasi dunia nyata, selain menawarkan kemungkinan bukti yang sangat ketat yang dapat dicapai dengan tipe dependen.

Tugas 1

module Main

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

Tugas 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

Yang ini bukan program tetapi hanya fungsi (lebih tepatnya, nilai dependen ), menghasilkan huruf N yang diinginkan sebagai array dua dimensi.

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

Tugas 3

module gcd

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

Perhatikan bahwa saya harus memilih nama gcd'karena seperti gcdyang sudah ditentukan dalam pendahuluan 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

Karena kita memiliki CJam, kita mungkin juga memiliki Pyth untuk kelengkapan :)

Pyth adalah bahasa golf oleh @isaacg yang mengkompilasi ke Python. Ini penting untuk menjadi prosedural dan untuk menggunakan notasi awalan. Pyth pertama kali muncul sekitar Juni 2014 .

"Halo Dunia!" Varian

"Pyth was made in 2014!

Perhatikan kurangnya kutipan penutup, yang merupakan opsional jika program Pyth berakhir dengan string.

ASCII Seni N

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

Cobalah online . Python yang setara adalah:

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

Atau diperluas (baris pertama dan ketiga tersirat):

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

Program ini menggunakan algoritma Euclidean, dan mengambil dua angka yang dipisahkan oleh baris baru. Cobalah online .

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

i.uQbahkan lebih pendek jika kita menggunakan builtin untuk GCD. Ini sama dengan print(gcd(*eval(input())))(mengambil dua angka yang dipisahkan koma sebagai input).

1964 - DASAR Dartmouth

BASIC adalah keluarga bahasa pemrograman tingkat tinggi tujuan umum yang filosofi desainnya menekankan kemudahan penggunaan. Pada tahun 1964, John G. Kemeny dan Thomas E. Kurtz merancang bahasa BASIC asli di Dartmouth College di New Hampshire. Mereka ingin memungkinkan siswa di bidang selain sains dan matematika untuk menggunakan komputer.

Saya melihat manual ini pada BASIC dari tahun 1964, dan emulator dari Sistem Berbagi Waktu Darthmouth ini dijalankan. Server masih menyala, tetapi sayangnya, mendaftarkan akun sepertinya tidak mungkin. Untuk saat ini, program-program ini secara teoritis akan berfungsi:

Tugas 1

10 PRINT "BASIC WAS MADE IN 1964"
20 END

Tugas 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

Mengeluarkan sesuatu seperti:

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

Perhatikan bagaimana input diketik sebagai bagian dari program ( 70 DATA 5); dengan READcara instruksi di atas mengambil data dari sana. Tidak ada penggabungan string, tetapi bagian 3.1 dari manual ini menjelaskan caranyaPRINT hasil dituliskan ke "zona" yang ditabulasi pada output.

Tugas 3

Algoritma Euclid versi lambat:

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

Keluaran:

2

2010 - WTFZOMFG

WTFZOMFG adalah bahasa esoterik berdasarkan Brainfuck. Itu dibuat oleh Jay Songdahl pada tahun 2010. "WTFZOMFG" adalah kependekan dari "What That Function? Zen Dioptimalkan File Gophers Berbahaya!" .

Berikut ini adalah kompiler untuk sistem * nix .

Tugas 1

'WTFZOMFG was made in 2010!\n"

Tugas 2

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

Penjelasan:

Maaf. Saya tidak pandai menulis penjelasan.

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

Tugas 3

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

Algoritma Euclidean. WTFZOMFG tidak memiliki perintah untuk mod, jadi saya harus menggunakan d(membagi), m(mengalikan) dan s(mengurangi).

2009 - Pergi

Go adalah bahasa pemrograman yang dikembangkan oleh Google. Pengembangan dimulai pada 2007, tetapi Go diumumkan pada November 2009.

Go adalah bahasa yang diketik secara statis yang dipengaruhi oleh C yang menekankan keringkasan, kesederhanaan, dan keamanan.

Tugas 1:

package main
import "fmt"

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

Baris pertama menyatakan paket kode. Bahkan contoh sederhana seperti mencetak satu baris harus menjadi bagian dari satu paket. Dan executable selalu dipanggil main.

Tugas 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 memiliki deklarasi variabel yang cukup ringkas ( i := 0sama dengan var i int = 0), dan kompiler menentukan jenisnya. Ini biasanya fitur yang lebih umum dalam bahasa dinamis. Menggunakan notasi singkat ini juga sangat mudah untuk menetapkan fungsi ke variabel ( f := func(x int) int {/* Code */}) dan membuat Penutupan.

Tugas 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))
}

Di sini Anda dapat melihat a, b = b, a%bsintaks, yang sangat bagus. Saya tidak tahu nama persisnya, tetapi dalam Python itu disebut tuple unpacking. Dengan menggunakan cara yang sama Anda dapat mengembalikan beberapa nilai dari suatu fungsi ( func f() (int, string) { return 42, "Hallo"}).

Hal lain yang terjadi dalam kode ini adalah loop. Untuk loop adalah satu-satunya loop di Go. Sementara loop atau do-while-loop tidak ada. Tetapi Anda dapat dengan mudah membuat yang setara untuk loop while for condition {}atau loop tak terbatas for {}.

1991 - Python

Sejarah Bahasa

Pada akhir 1980-an, Guido van Rossum mulai menganggap Python sebagai hobi. Namanya berasal dari Monty Python Flying Circus, sebuah acara televisi Inggris di mana Rossum adalah penggemar. Implementasi Python pertama dimulai pada tahun 1989 dan dirilis pada tahun 1991. Ini telah melonjak dalam popularitas selama bertahun-tahun, menjadi bahasa pilihan bagi banyak kursus ilmu komputer pengantar.

"Halo Dunia!" Varian

print("Python was made in 1991!")

Perhatikan tanda kurung di sekitar input print. Meskipun sintaks ini berfungsi dalam Python 2, biasanya dalam Python 2 Anda akan menghilangkan tanda kurung ini. Namun, mereka diperlukan dalam Python 3. Seperti yang disarankan oleh Zach Gates, tanda kurung digunakan di seluruh untuk memastikan bahwa kode yang disajikan di sini akan bekerja di berbagai versi.

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

Fungsi didefinisikan menggunakan def. Penggabungan string dilakukan menggunakan +dan pengulangan string dengan *.

GCD

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

Perhatikan bahwa Python membutuhkan spasi kosong terstruktur.

1968 - Algol 68

Algol 68 didefinisikan oleh Kelompok Kerja IFIP 2.1 sebagai penerus Algol 60.

Ini adalah bahasa yang berorientasi ekspresi di mana segala sesuatu memiliki nilai. Ini juga ortogonal, di mana Anda dapat menggunakan konstruksi apa pun dengan cara apa pun. Ini berarti bahwa ekspresi dapat berada di RHS dan LHS dari suatu tugas, misalnya.

Semua struktur kontrol memiliki bentuk yang disingkat dan bentuk yang panjang menggunakan ekspresi. Ini juga memungkinkan definisi operator.

Sasaran bahasa dikutip sebagai:

Tujuan utama dan prinsip-prinsip desain ALGOL 68:

• Kelengkapan dan kejelasan deskripsi
• Desain orthogonal,
• Keamanan,
• Efisiensi
• Pengecekan mode statis
• Penguraian mode-independen
• Kompilasi independen
• Optimasi putaran
• Representasi - dalam set karakter minimal & lebih besar

Program-program ini telah diuji dengan juru bahasa Algol 68 Genie , yang merupakan implementasi lengkap dari bahasa tersebut.

Beberapa fitur yang mungkin berbeda oleh programmer modern, adalah pernyataan kosong tidak diizinkan. Anda tidak bisa hanya menambahkan di ;mana saja. Anda harus menggunakan SKIPpernyataan jika Anda ingin memiliki apa-apa secara eksplisit. Ini juga memungkinkan pengkodean program bersamaan sangat mudah. Algol 68 juga, terutama, menggunakan kata kunci mundur sebagai terminator, seperti esac , od , fi dll.

Bahasa memiliki representasi yang digunakan untuk menulis kode yang menggunakan banyak font yang mewakili kata kunci dalam huruf tebal , dan pengidentifikasi dalam huruf miring , misalnya. Pada saat itu, dan mungkin masih, tidak ada kompiler yang mengimplementasikan fitur desain ini. Bahasa ini memungkinkan beberapa representasi konkret yang berbeda dari program menggunakan mode stropping . Ini memungkinkan program dipersiapkan menggunakan rangkaian karakter terbatas, seperti yang mungkin ditemukan di komputer pada 1960-an. Pertimbangkan fragmen program singkat, yang akan direpresentasikan sebagai:

jika saya < 0 maka lewati fi

Ini dapat disiapkan untuk kompiler dalam mode prime stropping sebagai:

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

Dalam mode dot stropping, ini akan menjadi:

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

Dalam mode case stropping ini akan menjadi:

IF i < 0 THEN SKIP FI

Saya sangat menyukai bahasa ini karena saya mengerjakan salah satu implementasi kompiler, serta pemrograman di dalamnya secara eksklusif selama bertahun-tahun.

Tugas 1

print (("Algol 68 dibuat tahun 1968!", baris baru ))

Poin yang perlu diperhatikan di sini adalah tanda kurung ganda. Ini karena cetak adalah fungsi yang mengambil argumen tunggal yang merupakan array panjang variabel dari penyatuan semua jenis. Tanda kurung bagian dalam adalah konstruktor array. Beginilah cara polimorfisme ditangani dalam bahasa yang sangat diketik ini.

Dalam mode stropping case:

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


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

Tugas 2

     int n ;
     baca (( n ));
     untuk i dari 1 ke n lakukan
          untuk j dari 1 ke n lakukan
               ¢ di sini kita menggunakan klausa IF disingkat ¢
               cetak ((( j = 1 OR j = i OR j = n |
                    "N"
               |
                    ""
               )))
          od ;
     print (( baris baru))
     od

Dalam mode stropping case:

 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

Tugas 3

     ¢ kita dapat mendefinisikan operator kita sendiri di Algol 68 ¢
     op % = ( int a , b ) int :
          (( b = 0 |
               a
          |
               b % ( a mod b )
          ));
     int i , j ;
     baca (( i , j ));
     cetak (( i % j , baris baru ))

Dalam mode stropping case:

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

The "StriNg Oriented and symBOlic Language". Pada awalnya tampaknya disebut Penafsir Simbolik Ekspresi, 'SEXI', yang kemudian harus diubah untuk mencegah kutu buku era 1960-an memerah ketika mengirimkan pekerjaan mereka. Kisah nyata.

Ini adalah salah satu bahasa pertama yang dapat menangani string dan pola secara asli. Memang, versi pertama SNOBOL memiliki string sebagai datatype -nya saja . Matematika kemudian dilakukan dengan parsing. Implementasi awal dilakukan pada IBM 7090. Tampaknya sudah lama berlalu, setidaknya, saya tidak bisa menemukannya. Apa yang saya temukan adalah makalah asli yang menggambarkannya serta juru bahasa SNOBOL3 di Jawa, yang dapat dijalankan pada komputer modern .

The SNOBOL pertama memiliki cukup banyak hanya pencocokan pola dan aritmatika dasar. SNOBOL 3 kemudian menambahkan fungsi dan mengubah I / O, tetapi sebaliknya tampaknya tetap kompatibel. SNOBOL 4 mengubah sintaksis, dan dari sana itu berkembang menjadi Icon , yang menjaga pencocokan pola tetapi hampir terlihat seperti bahasa pemrograman "normal" sebaliknya.

Program yang saya tulis hanya menggunakan fungsionalitas yang dijelaskan dalam kertas asli, jadi harus bekerja dengan SNOBOL asli dengan pengecualian I / O, yang saya lakukan dalam gaya SNOBOL3 sehingga penerjemah Java dapat menjalankannya. Dari makalah, tampaknya perbedaannya adalah bahwa SNOBOL1 menggunakan pencocokan pola dengan SYSvariabel khusus , sedangkan SNOBOL3 menggunakan variabel input dan output:

• Memasukkan:
  • 1 SYS .READ *DATA*
  • 3 DATA = SYSPPT
• Keluaran:
  • 1 SYS .PRINT 'A STRING' AND VARIABLES
  • 3 SYSPOT = 'A STRING' AND VARIABLES

Membuat pergantian ini akan membuat Anda menjadi 'nyata' SNOBOL 1. Tentu saja, maka Anda tidak dapat menjalankannya.

Tugas 1

START   SYSPOT = 'SNOBOL WAS MADE IN 1962!'

Tugas 2

Ini menunjukkan matematika, penanganan string dan kontrol aliran. SNOBOL3 memiliki fungsi yang berguna, seperti EQuntuk memeriksa kesetaraan; SNOBOL asli tidak, jadi saya belum menggunakannya.

* 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     

Tugas 3

Pertama, yang membosankan. Satu-satunya hal yang perlu diperhatikan adalah cek yang lebih kecil, yang menunjukkan dengan tepat bagaimana SNOBOL berorientasi string benar-benar: (B - A) '-'berarti "apakah hasil BA mengandung minus?". SNOBOL3 juga dapat melakukannya LE(B,A), tetapi SNOBOL 1 tidak bisa (setidaknya makalah tidak menyebutkannya).

* 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

Tentu saja, ketika Anda memiliki bahasa yang sepenuhnya berbasis string dan pencocokan pola, akan memalukan untuk tidak benar-benar menggunakan pencocokan dan penggantian pola. Jadi, inilah salah satu GCD berbasis unary, termasuk rutinitas untuk mengkonversi ke dan dari 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 adalah bahasa pemrograman open source gratis dan dikembangkan dan dikelola oleh Microsoft.

Tujuan utamanya adalah: Browser apa saja. Tuan rumah apa pun. OS apa saja. Sumber Terbuka. Album ini dirilis pada Oktober 2012

Halo TypeScript

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

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

coba online , dan screencast itu.

2011 - Dart

Dart adalah bahasa pemrograman Open Source yang dikembangkan oleh Google yang dikembangkan sebagai pengganti Javascript (walaupun dikompilasi ke javascript). Itu diresmikan oleh Google pada 2011 selama konferensi GOTO.

"Halo Dunia!" Varian:

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

ASCII Seni N:

Metode Bruteforce, berjalan pada 0 (n²), tetapi seharusnya tidak terlalu menjadi masalah kecuali Anda menggunakan angka raksasa.

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

Metode Euclid sederhana yang diporting dari Snap! contoh di atas.

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

Rust adalah tujuan umum, multi-paradigma, bahasa pemrograman yang disusun oleh Mozilla Research. Ini dirancang untuk menjadi "bahasa yang aman, konkuren, praktis", mendukung gaya fungsional murni, konkuren aktor, imperatif-prosedural, dan berorientasi objek. Wikipedia

Tugas 1

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

Tugas2

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

Penjelasan:

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

mengurus pencetakan hanya vertikal (kiri dan kanan |) dan diagonal ( \)

Tugas 3

implementasi sederhana 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 - Muffin MC

Muffin MC adalah bahasa makro Turing-lengkap, lucu (tapi serius), fungsional dan minimalis yang ditulis oleh Franck Porcher ( http://franckys.com ) pada pertengahan Februari 2015 karena kebutuhan sebagai alat (cepat) untuk memberdayakan suatu spreadsheet yang akan digunakan sebagai satu-satunya pengontrol front-end untuk menguji coba dan mengarahkan semua operasi terkait inventaris yang terkait dengan situs pedagang berbasis Prestashop untuk merek fesyen Tahiti baru: Mutiny Tahiti ( http://mutinytahiti.com - segera akan diluncurkan).

Muffin MC adalah akronim untuk MU mungil F unctional F lexible IN line M acro C ommand language.

Untuk memenuhi persyaratan kami, fitur inti Muffin MC telah dirancang dengan konstruksi semantik bawaan kelas 1 yang fleksibel dan efisien seperti iterator , evaluasi malas , multi-fungsi , produk string .

Muffin MC mengambil akarnya dalam pemrograman fungsional (pragmatis), FLisp dan Perl. Ini sepenuhnya mendukung rekursif (tanpa optimasi apa pun), diketik secara dinamis dan dibatasi secara dinamis (dangkal-mengikat). Ia menawarkan penggunanya satu struktur data saja, terlepas dari atom tipe-data dasar (atom, string, angka): daftar!

Semantik daftar MC Muffin (jenis) meminjam pada set daya semantik , yaitu:

1. Semua Muffin operasi MC menghasilkan daftar, mungkin kosong.
2. Akses ke elemen daftar individual apa pun selalu menghasilkan daftar satu nilai yang dibuat dari elemen itu (anggap sebagai singleton).
3. Daftar kosong adalah elemen netral pada operasi daftar.

Untuk berdamai dengan ini, hal-hal berikut dapat membantu:

• Seseorang dapat memvisualisasikan daftar sebagai elemen dari set kekuatan daftar yang memiliki kardinalitas terbesar.
• Visualisasikan elemen daftar sebagai elemen set daya daftar yang merupakan singleton yang dibuat dari elemen itu.
• Visualisasikan daftar kosong sebagai set kosong; yaitu, satu-satunya elemen set daya set kosong.

Dengan demikian, mengakses elemen daftar kosong menghasilkan daftar kosong, dan bukan kesalahan! Memang, Muffin MC berusaha keras untuk melemparkan kesalahan sesedikit mungkin dengan memperluas semantik banyak operasi tradisional.

Tugas 1

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

#(...)adalah perintah makro Muffin MC untuk menerapkan fungsi pada daftar argumen yang tidak ditampilkan, di sini fungsi bawaan say, yang dipinjam dari Perl.

#(say 1 2 3 ...) secara fungsional identik dengan map {say $_} (1,2,3,...)

Tugas 2

Tentukan fungsi 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()Bentuk kerja terpendek (88 byte):

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

• =(var val...)adalah perintah makro Muffin MC untuk mendefinisikan variabel, atau menugaskannya kembali.

• $(var)adalah perintah makro Muffin MC untuk mengakses nilai variabel. Itu secara alami menerima formulir $(v1 v2 ...)untuk mengakses banyak variabel sekaligus.

• =(* var1 val1 var2 val2 ...)adalah perpanjangan dari perintah makro Muffin MC=(...) untuk menangani penugasan paralel.

• Variabel _1, _2, ... dibatasi secara dinamis (mekanisme pengikatan dangkal) dan secara otomatis diatur untuk mengikat argumen fungsi. Dipinjam dari Perl5, variabel sistem #(jumlah argumen) dan @(daftar argumen) juga ditetapkan secara otomatis.

• Fungsi hanyalah variabel yang terikat pada sejumlah pernyataan Muffin MC .

Solusi menarik ini berasal dari menggabungkan dua fitur bawaan Muffin MC :

1. Perintah makro Muffin MC I(...) , untuk mendefinisikan siklus-iterator, yang kemudian digunakan dengan bentuk fungsional #(my-iterator want-number-of-values),

2. Konstruk produk string Muffin MC , ekstensi dari interpolasi variabel alami, yang, diberikan string apa pun , di mana F i adalah string Muffin MC literal atau perintah makro Muffin MC (alias bentuk fungsional), akan menghasilkan sebanyak string diberikan oleh produk kardinal (F1) x kardinal (F2) x ...."F1 F2 F3..."

Misalnya, diberikan variabel xa yang memegang 2 nilai, kata a dan b, dan variabel lain y yang memegang 3 nilai, mengatakan, 1 2 3, maka evaluasi string "x=$(x) y=$(y))"akan menghasilkan 6 nilai yang berbeda, yaitu, dalam urutan itu:

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

Ini adalah salah satu fitur yang sangat diinginkan dari proyek MUTINY yang dirancang untuk Muffin MC .

Menjalankannya !

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

bagaimana cara kerjanya

Algoritma kami didasarkan pada yang berikut:

Diberi panggilan ke ascii-art (n), {n = 2p + 1 | p integer, p> = 0}, seni untuk menghasilkan terdiri dari n string n karakter, di antaranya, dua, yang paling kiri dan paling kanan, adalah tetap dan selalu sama: 'N'. Hal ini memungkinkan untuk mengurangi masalah dalam memproduksi hanya string tengah. Sebagai contoh, mengingat n = 5, kami ingin menghasilkan 5 string tengah berikut, masing-masing terbuat dari n-2 karakter (kami telah mengganti spasi dengan '_' demi visualisasi yang lebih baik):

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

• String tengah semacam itu dapat dengan mudah diproduksi dengan bersepeda di atas urutan 4 elemen ('_' '_' '_' 'N')dalam 5 grup 3; diberikan n, input fungsi, urutan tersebut dibuat dari n-2 karakter '_', diikuti oleh karakter 'N'. Bersepeda di atas urutan ini tidak membutuhkan apa pun selain menyisipkan urutan di dalam iterator bawaan Muffin MC I(sequence) (sebuah iterator yang berputar selamanya atas urutan nilai awalnya).

• Kami kemudian hanya menghasilkan string tengah, panjang n-2, dengan meminta iterator kami untuk memberi kami nilai n-2 berikutnya (n - 2 karakter), yang digabungkan bersama untuk menghasilkan string tengah yang diharapkan.

• String n tengah diproduksi dengan mengulangi n kali proses di atas, menggunakan peta untuk mengumpulkan hasil n (n string n-2 karakter).

• Kami menggunakan kuat Muffin lain MC built-in konstruk, yaitu produk tali , untuk menghasilkan string akhir n: "N#(map...)N".

• Dan itu dia!

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

Tugas 3

Tentukan fungsi gcd():

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

gcd()'s nyata bentuk terpendek (37 bytes - 2bytes mendapatkan berkat Rodolvertice)

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

Menjalankannya !

#(gcd 225 81)

hasil 9.

Itu dia.

Terima kasih atas permainan yang bagus, dan mungkin atas minat Anda. Bahasa ini tersedia untuk siapa saja yang ingin bermain, menggunakannya, atau bahkan memperluasnya. Tanyakan saja dan saya akan senang mengirimkannya.

Tepuk tangan

Franck

PS. Implementasi Muffin MC saat ini ada di Perl5. Kode sumbernya adalah sekitar 2000 baris Perl modern, termasuk komentar, dan dibundel dengan non-regresi test-suite, yang bagus untuk mempelajari langsung konstruksi dan semantik Muffin MC .