Bu zorlukla, kullanıcılar, sırayla daha yaşlı olmalarına izin verilen programlama dillerinde oldukça basit üç kodlama görevini yerine getireceklerdir.

İlk cevap 2015 yılında yapılan bir programlama dilini kullanmalıdır. 2015 dilinden en az bir cevap alındığında, cevaplar 2014 yılında yapılan programlama dillerini kullanabilir. en az bir 2014 cevabı bulunana kadar.

Genel olarak, Y yılından itibaren bir programlama dilinin kullanılması, Y + 1 yılından bir dil kullanılarak cevaplanıncaya kadar izin verilmez. Tek istisna Y = 2015.

Dilinizin Yılı Bulunması

Bu soruyu cevaplamak için, programlama dilinizin "yapıldığı" yılı bilmeniz gerekir. Bu elbette öznel bir terimdir; bazı diller, birkaç yıl boyunca geliştirilmiştir ve birçok dil hala her yıl yükseltilmektedir. Bir dilin "yapıldığı" yıl, genel olarak bu dil için bir uygulama ortaya çıkmış ilk yıl olsun.

Örneğin, Python 1991'de "yapımı" yapıldı , ancak 1989'dan bu yana gelişimi devam ediyordu ve sürüm 1.0 1994'e kadar piyasaya sürülmemişti.

Bu yıl hala öznel ise, en uygun yılı seçmek için sağduyunuzu kullanın. Yıl seçimleriyle ilgili ufak tefek kazalara boğulmayın. Lütfen, dilinizin ne zaman yapıldığını söyleyen bir kaynağa link verin.

Bir programlama dilinin farklı versiyonları veya standartları (örn. Python 1, 2, 3) aynı ilk yıl ile aynı dilde sayılır.

Bu nedenle, dilinizin 2015 yılı olmadığı sürece, cevabınızı ancak dilinin yılı sizinkinden önceki yıl olan bir cevap gönderildikten sonra gönderebilirsiniz.

Sizinkinin aynısı olan geçerli bir cevap varsa, cevap verebilirsiniz. Dilinizin yılın başında mı yoksa sonrasında mı geliştirildiği önemli değildir.

Görevler

Görev 1 ila 3'ü tamamlamanız gerekir. Görev 0 isteğe bağlıdır.

Bu görevler, programlamanın üç önemli yönüne karşılık gelmek üzere seçildi: çıktı sağlama (Görev 1), döngü (Görev 2) ve özyineleme (Görev 3).

Görev 0 - Dil Geçmişi (isteğe bağlı)

En azından seçtiğiniz programlama dilinin tarihini açıklayan bir paragraf yazın: kim geliştirdi, niçin, nasıl, vb. Dilin sizin veya işiniz üzerindeki etkisi veya bunun gibi şeyler hakkındaki kişisel anekdotları kullanmaktan çekinmeyin.

Çok fazla araştırma yapmadan dilinizin tarihi hakkında daha fazla bilgi edinmek için çok gençseniz, yazınızı düzenleyebileceklerini ve bazı ilk elden geçmişlerini ekleyebileceklerini söyleyen yaşlı kullanıcılara not bırakmayı düşünün.

Görev 1 - "Merhaba, Dünya!" varyant

Yazdıran bir program yazın

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

Dilinizin standart çıktı alanına (en yeni diller için stdout).

Örneğin, dil Python olsaydı, çıktı şöyle olurdu:

Python was made in 1991!

Görev 2 - ASCII Art N

Kullanıcının tuhaf bir pozitif tamsayı girmesine izin veren bir program yazın (girişin her zaman geçerli olduğunu varsayabilirsiniz) ve karakteri kullanarak yapılan bir ASCII N harfi yazdırır N.

Giriş 1 ise, çıkış:

N

Giriş 3 ise, çıkış:

N N
NNN
N N

Giriş 5 ise, çıkış:

N   N
NN  N
N N N
N  NN
N   N

Giriş 7 ise, çıkış:

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

Desen bu şekilde devam ediyor. Çıktı izleyen boşluklar içerebilir.

Görev 3 - GCD

Kullanıcının iki pozitif tamsayı girmesine izin veren bir program yazın (girişin her zaman geçerli olduğunu varsayabilirsiniz) ve en büyük ortak bölenlerini yazdırır . Bu, kalanları bırakmadan her iki sayıyı da bölen en büyük pozitif tamsayı olarak tanımlanır. Öklid algoritması kullanılarak kolayca hesaplanabilir .

Örnekler:

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

Yerleşik bir işlev kullanabilirsiniz, ancak dilinizin ilk sürümünde olup olmadığını öğrenmeyi deneyin. Değilse, kullanmamaya çalışın.

kurallar

• Birden çok kez cevap verebilirsiniz, ancak her yeni cevap, son cevabınızda dilden en az 5 yıl önce yapılmış bir dil kullanmalıdır. Yani, bir 2015 diliyle cevap verdiyseniz, 2010 diline izin verilene kadar bir daha cevap veremezsiniz. Bir 2010 cevabıyla başlarsanız, ikinci cevabınızı bir 2015 cevabı yapamazsınız çünkü 2015 2010'dan önce değildir.
• Mümkünse, kodunuzu dilinizin ilk sürümünde (veya olabildiğince eski bir sürümde) çalışacak şekilde yazın. (Bu bir gereklilik değildir, çünkü bazı diller için eski derleyiciler / tercümanlar bulmak zor olabilir.)
• Gönderilen cevapta önemli hatalar olmadıkça veya görevleri tamamlama yolunuz çok farklıysa, zaten gönderilmiş bir dili yayınlamaktan kaçının.
• Kodunuzu golf oynamak iyi, ancak gerekli değil.
• Herhangi bir programın çıktısında izleyen bir satırsonu gayet iyi.
• Görev 2 ve 3 için, 2 ¹⁶ gibi makul bir maksimumun altındaki tüm giriş değerleri çalışmalıdır (en azından 256).
• Bu soru gönderilmeden önce diliniz mevcut olmalı.
• Çok eski programlama dilleri, bugün düşündüğümüzden farklı girdi ve çıktı biçimlerine sahip olabilir. Bu iyi. Kendi dilinizde en iyi şekilde yeteneklerinizi tamamlayın.

puanlama

Gönderinizin puanı:

upvotes - downvotes + (2015 - languageYear) / 2 

Böylece, 2015'ten önceki her yıl için oy sayısına 0.5 eklenir ve böylece eski dillere avantaj sağlanır. En yüksek puana sahip olan gönderim kazanır.

Cevap Listesi

Aşağıdaki Yığın Parçacığı, tüm geçerli cevapları dil yıllarına göre listeler.

Doğru listelenmesini sağlamak için yayınınızı bu Markdown satırıyla başlatmalısınız :

#[year] - [language name]

Örneğin:

#1991 - Python

Dil adı bir bağlantıda olabilir (cevap listesindeki bağlantı aynı olacaktır):

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

Bu formata uymayan, henüz izin verilmeyen bir yıla sahip veya son 5 yıl içinde zaten cevaplanmış bir kullanıcıdan gelen cevaplar geçersiz olarak işaretlenmiştir.

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

2013 - Dogescript

Dogescript , 2013 yılında Zach Bruggeman tarafından oluşturulan bir dildir. Javascript'in memetik Shiba Inus'un iç monologları gibi okunması için bir sözdiziminden başka bir şey değildir.

Merhaba doge

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

ASCII Sanatı

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, regex'i bazı ev sahibi dillerinde çağırmanın gereksiz yükü olmadan, PPCG mücadelelerinde sadece regex cevaplarıyla rekabet edebilmek için yazdığım regex tabanlı bir programlama dilidir. Retina Turing tamamlandı. Bunu ispatlamak için Kural 110'a ek olarak 2 etiketli bir sistem çözücüsü kullandım . C # ile yazılmıştır, bu nedenle hem .NET lezzetini (varsayılan olarak) hem de ECMAScript lezzetini (bayrakla) destekler.

Retina çoklu modlarda çalışabilir, ancak hesaplamalar için en uygun olanı (ve Turing-complete olanı) Replace modudur. Değiştir modunda, Retina'ya eşit sayıda kaynak dosya verirsiniz. Bunlar daha sonra eşleştirilir, her bir çiftin ilki bir regex, ikincisi bir ikamedir. Bunlar daha sonra girişi adım adım manipüle ederek sırayla gerçekleştirilir. Regex ayrıca bir konfigürasyondan önce gelebilir (ile ayrılmış `). En önemli seçenek (Retina Turing'i tamamlayan), +Retina'nın değiştirmeyi, sonuç değişmeyi bırakıncaya kadar bir döngüde uygulayabilmesidir. Aşağıdaki örneklerde, ;ara aşamalarda çıktıyı bastıran aynı zamanda kullanıyorum .

Aşağıdaki gönderilerin her birinde, her satır ayrı bir kaynak dosyasına gider. (Alternatif olarak, yeni -sseçeneği kullanabilir ve tüm satırları tek bir dosyaya koyabilirsiniz.) Boş dosyalar / satırlar olarak gösterilir <empty>. Tek bir boşluk içeren dosyalar / çizgiler olarak temsil edilir <space>.

Açıklamalar oldukça uzun, bu yüzden onları gönderinin sonuna taşıdım.

Programlar

"Selam Dünya!" varyant

<empty>
Retina was made in 2015!

ASCII Art N

Bu, STDIN'in yeni bir satırla sonlandırıldığını varsayar.

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

Bu STDIN gerektirir değil bir yeni satır ile sonlandırıldı.

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

açıklamalar

"Selam Dünya!" varyant

Bu oldukça önemsiz. Girdi almaz (yani boş bir dize), hiçbir şeyle eşleşmez ve yerine geçer Retina was made in 2015!. Biri, [\s\S]*örneğin kalıbı değiştirerek, isteğe bağlı girdiler için çalışmasını da sağlayabilir . Bu STDIN'i çökertecek ve hepsini çıkışla değiştirecekti.

ASCII Art N

Bunun oldukça fazla aşaması var. Buradaki fikir girdiyi birliğe dönüştürmek, bir N x N bloğu oluşturmak Nve sonra iki üçgeni "oymak" tır. Bireysel aşamalardan geçelim. Unutmayın ki, ;yalnızca ara çıktıları bastırır, ancak +değişimin bir döngüye uygulanmasına neden olur.

;`^
#

Basit: #Girdiye bir a hazırlayın . Bu unary dönüşümünde bir işaretleyici olarak kullanılacaktır.

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

Bu, bir basamağı birliğe çevirir. Önceden dönüştürülmüş sayıları alır ve (\d*)10 kez tekrar eder. Sonra bir sonraki rakamı alır ve uygun rakam sayısını ekler. Rakamların gerçek değeri bu aşamada önemli değil. Ne zaman #numarasının sonuna geldiğinde, normal ifade artık maçları ve dönüşüm yapılır. Örnek olarak, numara olarak 127kabul edilecektir.

#127
1#27
111111111122#7
1111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111227777777#

son satır tam olarak 127 basamaklı karakterler içeriyor.

;`#
<empty>
;`\d
N

Bundan kurtulup #tüm basamakları dönüştüren iki basit aşama N. Aşağıda, girişi 7örnek olarak kullanacağım . Şimdi biz var

NNNNNNN

Sonraki bölüm

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

her birini Ndizenin tamamı ile değiştirir (izleyen bir yeni satır içerdiğini unutmayın) ve izleyen yeni satırın kendisini de kaldırır. Bu nedenle, bu tek sırayı kare bir ızgaraya dönüştürür:

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN

Şimdi üst üçgen. İlk önce, sağ alt köşedeki N'yi bir boşluğa çevirerek işleri başlatırız:

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

Göz alıcı, doğru olanı değiştirmemizi sağlar N. Bu verir

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNN N
NNNNNNN
NNNNNNN

Ve şimdi

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

Nboşluk karakterinin sol üst köşesinde veya üstünde olanla eşleşen ve bir boşlukla değiştirilen bir regex'tir. Değişim tekrarlandığından, bu esasen 3. oktantı başlangıçtaki boşluktan daha fazla alana çeviren bir taşkın dolgusudur:

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

Ve son olarak, aynı şeyi alt üçgenle tekrarlıyoruz, ancak farklı bir karakter kullanıyoruz, bu yüzden zaten var olan alanlar yanlış bir taşma dolgusuna neden olmaz:

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

tohum ayarlar:

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

Sonra

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

sel doldurur.

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

Ve sonunda

S
<space>

Bunları Sboşluklara çevirir ve bittikten sonra:

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

GCD

Tekdüze GCD aslında regex ile çok önemsiz. Bunların çoğu ondalık basamağa, unary ila basamağa dönüşümden oluşur. Bu daha kompakt bir şekilde yapılabilirdi, ama bu bir kod golf değil, bu yüzden ...

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

Bu aşamalar, her iki giriş numarasının dönüştürülmesi ve sonuç 1yerine s yerine s kullanması dışında, esas olarak yukarıdakilerle aynıdır N(önemli değil). Yani girdi 18 24olsaydı, o zaman bu üretecek

111111111111111111 111111111111111111111111

şimdi

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

tüm GCD hesaplamasıdır. Çok sayıda 1s yakalayarak ve sonra her iki sayının da o dizgiyi tekrarlayarak (ve başka hiçbir şey yapmadan) yazılmasını sağlamak için geri referanslar kullanarak ortak bir bölenle eşleşiriz. Regex motorunda geri izlemenin nasıl çalıştığı (yani .+açgözlü) nedeniyle, bu her zaman en büyük ortak böleni otomatik olarak verir. Maç tüm dizgiyi kapsadığı için GCD'mi almak için ilk çekim grubunu tekrar yazıyoruz.

Sonunda, ondalık dönüşüm için unary ...

;`$
#:0123456789

Dizeye bir işaretleyici #, sınırlayıcı :ve tüm basamaklar ekleyin . Bu gereklidir, çünkü kurallı olarak regex değişiminde yeni karakterler üretemezsiniz. Koşullu değiştirme istiyorsanız, karakterleri dizgiden çekmeniz gerekir, bu yüzden onları oraya koyarız.

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

Bu daha önceki unary genişlemesinin tersidir. Geçerli dizgeye uyan en büyük 10 tanesini buluruz. Ardından kalanı temel alan bir sonraki haneyi seçer ve işaretçiyi rakamlar arasında hareket ettirirken çarpımı 10'a böleriz.

#|:.*
<empty>

Ve son olarak, işaretleyiciden, sınırlayıcıdan ve yardımcı rakamlardan kurtulmak için yalnızca bir temizleme adımı.

2013 - Yapış !

Snap ! Berkeley Üniversitesi'nde yapılan Scratch dayalı bir dildir . Birinci sınıf veri ve özel bloklar (fonksiyonlar) içeren Scratch'a yükseltmedir. Scratch gibi, metin tabanlı değil, bir araya gelen görsel "bloklar" tarafından yapılır.

Snap ! JavaScript ile yazılmış, Squeak Smalltalk ile yazılmış BYOB, halefidir. Snap ! kamu tüketimi için Mart 2013’te beta sürümü yayınlandı .

Snap ! aslında ezoterik bir dil değil. Berkeley ve diğerlerinde Bilgisayarların Güzelliği ve Sevinci (BJC) AP CS kursu için programlama dili olarak kullanılır .

Testler ve malzeme konusunda yardımcı oldum.

"Merhaba Dünya" değişkeni

ASCII Sanat "N"

Bu, bazı bloklar için stdlib'i kullanır.

Burada oldukça basit bir döngü var. Bir giriş alır. Sonra hepsini bir araya getiririz ve söyleriz (n = 5 için sonuç):

Buradaki özgürlüğü 1 yerine 2 boşluk kullanmak için kullandım, çünkü Snap! monospace içinde şeyler söylemez.

GCD

Öklid algoritması çok hızlı değildir, ancak çalışır ve oldukça basittir. (Üzgünüm, blok adına bir yazım hatası yaptım. Şimdi sekmeyi kaydetmeden kapattım. Kalmak zorunda kalacağım.)

Bu fonksiyon tanımı daha sonra bu bloğu üretecektir:

2007 - LOLKOD

Dil tarihi

LOLCODE, 2007 yılında Lancaster Üniversitesi'nde araştırmacı olan Adam Lindsay tarafından kuruldu. Sözdizimi, Cheezburger, Inc. tarafından popülerleştirilen lolcats memlerine dayanmaktadır.

"Selam Dünya!" varyant

HAI
VISIBLE "LOLCODE wuz maed in 2007!"
KTHXBYE

ASCII Art N

HAI

BTW, read n from stdin
GIMMEH n

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

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

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

        VISIBLE "N"

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

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

            VISIBLE "N"
        IM OUTTA YR closet

        VISIBLE "N"!

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

        VISIBLE "N"
OIC

KTHXBYE

Değerler, stdin'den gelen dizeler (YARN) olarak okunur GIMMEH. 1 ile çarparak sayısal değere (NUMBR) dönüştürülebilirler.

Değerler kullanılarak stdout'a yazdırılır VISIBLE. Varsayılan olarak yeni bir satır eklenir, ancak ünlem işareti eklenerek bastırılabilir.

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 string birleştirme gerçekleştirir.

1982 - PostScript

PostScript, vektör grafikleri oluşturmak ve yazdırmak için kullanılan bir dildir.

Adobe 1982 yılında kuruldu ve ilk ürünü PostScript oldu. Dil yazıcılarda kullanılmıştır: komutlar yazıcı tarafından yorumlanır ve daha sonra sayfaya basılır. 1990'lı yıllara kadar lazer yazıcıların çok yaygın bir parçasıydı. Ancak açıkça yazıcıda oldukça yoğun CPU kullanımı var ve bilgisayar işlemcileri güçlendikçe, bilgisayarda rasterleştirmeyi yapmak yazıcıdan daha anlamlıydı. PostScript, bir çok daha ileri seviye yazıcıda hala var olmasına rağmen, tüketici yazıcılarında büyük ölçüde kayboldu.

PostScript'in yerini alan standart, PDF adı verilen az bilinen bir formattır.

PostScript, programlamaya başladığımda modası geçmiş bir durumdaydı, ancak üniversitedeyken TeX için belge oluşturmanın başka bir yolu olarak biraz öğrendim. Kullandığım diğer programlama dillerinden oldukça farklıydı (ters yerleştirme notasyonu, yığın, konsol yerine bir sayfaya yazdırma), ancak bu eski dili biraz eğlenmek için çıkarmak güzeldi.

PostScript bir yazdırma dili olduğundan, bir şeyi yazdırmak ve ardından konsola bir çıktı göndermek için kullanmak daha uygun görünmektedir.

Görev 1

/Courier findfont
12 scalefont
setfont
newpath

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

İlk birkaç satır, çizilmesi için bir tuval oluşturdu. Ardından movetokomut PS'ye belirli bir konumda çizmesini söyler showve dizeyi sayfaya yazdırır. Parantezlerin, PostScript'te tırnak işaretleri yerine bir dize olarak işaretlendiğini unutmayın.

Görev 2

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

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

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

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

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

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

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

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

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

  } repeat

  end
} def

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

“ASCII art” N çizilmesi için bir fonksiyon yazdım, ancak PostScript fonksiyonlarının tartışmaya girmesine imkân yok. Bunun yerine, argümanlarınızı yığına itin, sonra geri alın. İşte bu /x exch def.

Bir örnek: yığının öyle olduğunu varsayalım 8 9 2. İlk önce adı /xyığına iteriz, o yüzden yığına 8 9 2 /x. exchOperatör iki yığın değerleri değiştirir, şimdi yığın 8 9 /x 2. Daha sonra defüst iki yığın değerleri açılır ve tanımlar /xdeğere sahip 2. Yığın şimdi 8 9.

PostScript kullanmaya başladığımda, bunu biraz kafa karıştırıcı buldum. Yığını teorik bir kavram olarak okudum, ama pratikte ilk kullandığım zamandı.

İşlevin geri kalanı bazı çizim kodlarıdır: sağ alt köşeden başlayıp soldan sağa ve çaprazdan bir seferde bir sıra doldurarak başlayın.

Görev 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

Yine, bir Euclid algoritması kullandım, ancak PostScript'in yerleşik bir modulo işleci olduğunu unutmuştum, bu yüzden kendim yazmak zorunda kaldım. Bu, yığın tabanlı programlamanın kısıtlarının yararlı bir hatırlatıcısı olduğu ortaya çıktı. İlk uygulamam moduloözyinelemeye dayanıyordu:

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

Bu x, büyük ve yküçük olduğunda bunu çalıştırmayı deneyene kadar iyidir (örneğin, 5689 ve 2). Yığında yalnızca 250 öğeye sahip olabilirsiniz ve bu yüzden yığın sınırını çok iyi geçiyordum. Hata. Bu konuda çizim tahtasına geri dönmek zorunda kaldım.

GCD kodunun kendisi oldukça basittir. Fakat fonksiyonların argüman alamadığı gibi geri dönüş değerleri de yoktur. Bunun yerine, sonucu bir başkasının daha sonra çıkarabileceği yığına itmek zorundasınız. Bu ave b a gcdçizgilerinin yaptığı şeydir : değerlendirmeyi bitirdiklerinde değeri yığına itmektedirler.

Tüm kodu bir belgeye koyar ve yazdırırsanız, çıktı şöyle görünür:

2009 - > <>

Befunge'den ilham alan> <> (Balık) ezoterik bir yığın tabanlı 2D dildir, yani program akışı yukarı, aşağı, sola veya sağa olabilir. > <> 'İn ilk sürümünde çok sayıda iş parçacığı yer aldı [ve ]oluşturdu ve sonlandırdı;

> <> İçin şu anki resmi tercüman burada bulunabilir . Ne yazık ki, Esolang wiki'deki eski tercümana bağlantı koptu.

"Selam Dünya!" varyant

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

İpin geriye doğru nasıl yazıldığına dikkat edin -> <> teknik olarak karakter dizileri yoktur, sadece veri türü garip bir char, int ve float karışımıdır. "dize ayrıştırma işlemini değiştirir, her bir karakter bir kapanış gerçekleşene kadar yığının üzerine "itilir.

Kodun ikinci yarısı daha sonra yığının uzunluğunu iter, lsıfır ?!olup olmadığını kontrol eder ve eğer öyleyse program sonlandırılır ;. Aksi halde komut göstericisi devam eder, oyürütmeden önce yığının tepesini çıkartarak bb+0., göstergeyi (22, 0)hemen önce konumlandırmak üzere lbir döngü oluşturarak ışınlar.

ASCII Art N

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

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

   \                                                         <   /

Netlik için boşluk ile. Bunu burada yeni çevrimiçi tercümanda deneyebilir ve talimat göstergesinin etrafta dolaştığını görebilirsiniz - sadece "İlk Yığın" metin kutusuna bir sayı girmeyi unutmayın. Python yorumlayıcısı aracılığıyla çalışıyorsanız -v, yığını başlatmak için bayrağı kullanın;

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

Bu program için girdiyi nsicile koyar ve "iterasyonlar" için &çağıracağımız 0'a ibasarız. Programın geri kalanı bu gibi gider dev bir döngüdür:

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

Sonra döngüyü baştan tekrarlıyoruz.

Oklar ^>v<program akış yönünü değiştirir ve aynalar /\program akış yönünü yansıtır.

GCD

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

İşte bir golf>> programının neye benzediğine bir örnek. Bir kez daha, bunu çevrimiçi tercümanda deneyebilirsiniz (örneğin, "İlk yığın" kutusuna virgülle ayrılmış iki değer girin 111, 87) veya -vPython tercüman bayrağını kullanarak , örneğin

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

Bu program Öklid algoritmasını kullanır. İşte daha önce hazırladığım bir GIF:

> <> 'Nın toroidal olduğuna dikkat edin, bu nedenle sol alt vkomut yürütüldüğünde komut göstericisi aşağıya doğru gider, etrafına sarılır ve en üste yeniden çıkar.

Düzenleme: Kodun tamamen sağdan sola çalışmasını sağlayarak , @randomra üç byte'ı tıraş etmeyi başardı.

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

Sanırım yeterince golf oynamadım :)

2012 - Öğe

Bu 2012'nin başında basit bir golf dili olmak için icat ettiğim bir dil. Bununla, operatör aşırı yüklenmesinin çok az veya hiç olmadığı anlamına gelir. Operatörler aynı zamanda çoğu modern golf diline göre daha basit ve daha az sayıdadır.

Bu dilin en ilginç özellikleri veri yapılarıdır. Orada iki yığınlarının ve bilgi depolamak için kullanılan bir karması.

M-yığını, aritmetik ve diğer birçok işlemin gerçekleştiği ana yığittir. Veriler girildiğinde veya yazdırıldığında, nereye gideceği veya alındığı yer burasıdır.

C yığını, kontrol yığınıdır. Boole aritmetiğinin gerçekleştiği yer burasıdır. C-yığınının üst değerleri, If ve While tarafından koşul olarak kullanılır.

Karma değişkenlerin saklandığı yerdir. ;Ve ~depolamak ve sırasıyla karma veri almak.

Öğe çok zayıf yazılmış bir dildir. Perl'in sayıları serbestçe dizge ve tersi olarak yorumlama yeteneğini kullanır.

Ben onun yanındayken, dilin tüm belgelerini de ekleyebilirim. Sen bulabilirsiniz orijinal sağ Perl ile yazılmış 2012 tercüman, buraya . Güncelleme: Burada bulabileceğiniz daha kullanışlı bir sürüm oluşturdum .

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 \

Görev 1 - Metin Yazdır

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

Dilin en garip kısımlarından biri, dize sınırlayıcılarının eksikliğidir, bu yüzden bu karakterde kaçış karakterlerine ihtiyaç duyulmaktadır. `Sonunda dize yazdırır.

Görev 2 - ASCII Art N

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

Burada, bazı yığın manipülasyonlarına şahit olacaksınız. Açıklamayı biçimlendirmek biraz daha kolay hale getirmek için, newline ile bir Lve boşluk ile değiştireceğim 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

Bu cevabın bazı aşırı golf yaptıktan sonra, çok daha karmaşık olmasına rağmen, 39 baytlık bir çözüm buldum.

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

Görev 3 - GCD

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

Bu yığın tabanlı bir yöntemdir.

__                 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

Dil tarihi

Julia, 2012 yılında Jeff Bezanson, Stefan Karpinski ve Viral Shah tarafından geliştirildi. Çeşitli uygulamalarda kullanım kolaylığını korurken, açık kaynak, hızlı ve dinamik (birçok şey arasında) olan bir programlama dili arzusuyla motive oldular. Ürün, yüksek performanslı bilimsel hesaplamalara yeni bir yaklaşım olan Julia idi.

"Selam Dünya!" varyant

println("Julia was made in 2012!")

Julia'da STDOUT'a baskı yapmak oldukça basittir!

ASCII Art N

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

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

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

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

Kod okunabilirlik için girintilidir, ancak Julia, boşluklara herhangi bir kısıtlama getirmez.

GCD

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

İşlevde listelenen son şey örtük olarak döndürülür.

1988 - Mathematica

Yoksa Wolfram Dili mi demeliyim ?

Görev 0

Mathematica'nın yaratıcısı, Wolfram Research'ün Kurucusu ve CEO'su Stephen Wolfram'dır. Mathematica'nın gelişmesinden önce fizikçi idi. Fizikte çok miktarda cebirsel hesaplama vardı, bu yüzden Macsyma kullanıcısı oldu .

Wolfram, 1979 yılında doktorasını 20 yaşındayken aldı. Fizik yapmak için Macsyma'dan daha iyi bir CAS'a ihtiyacı olduğunu düşündü ve SMP ("Sembolik Manipülasyon Programı") yazmaya başladı . SMP'nin ilk sürümü 1981'de piyasaya sürüldü. SMP, Mathematica'nın öncülüydü. Mathematica üzerinde derin bir etkisi olmasına rağmen, hiçbir kodu Mathematica için kullanılmadı.

1986 yılında, Wolfram bir "nihai hesaplama sistemi" yazmaya karar verdi. 1986'da kodu yazmaya başladı ve 1987'de Wolfram Research'ü kurdu. Sonunda, 23 Haziran 1988'de Mathematica 1.0 piyasaya sürüldü.

Mathematica 1.0'ı bulamadım. Aslında, Mathematica 1.0'ın bir Windows ya da Linux sürümü yoktu. Ancak Çinli bir web sitesinde Mathematica 2.0'ı buldum. Hala Windows XP'de çalıştırılabilir.

Görev 1

Print["Mathematica was made in 1988!"]

Ya da sadece:

"Mathematica was made in 1988!"

Görev 2

Bugünün Mathematica'sında şunları yazabiliriz:

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

Tıpkı Julia ve R gibi , bu bir matris çözümüdür. Mathematica'da, desen eşleştirmeyi kullanarak seyrek bir matris tanımlayabilirsiniz.

Ancak, SparseArrayMathematica 5.0'da tanıtıldı, bu yüzden Mathematica 1.0'da kullanamayız.

İşte Mathematica 1.0'da çalışan bir çözüm:

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

Yazamıyoruz f[i_, 1 | i_ | n] = "N"çünkü AlternativesMathematica 2.0'da tanıtıldı.

Görev 3

Sadece yerleşik işlevi kullanabiliriz:

gcd = GCD

Veya GCD'nin tanımını kullanabiliriz:

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

Ya da kullanabilir LCM olsa daha yaygın LCM OBEB hesaplanır:

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

Veya Öklid algoritmasını desen eşleştirme ile kullanabiliriz:

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

Veya anonim bir işlev olarak:

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

Yukarıdaki tüm fonksiyonlar Mathematica 1.0'da tanıtıldı.

1999 - XSLT

World Wide Web Konsorsiyumu (W3C) Aşağıdaki örnekler girdi içine alınır varsayalım vb HTML, metin, içine XML dönüştürmek için XSLT oluşturulan <input>..</input>etiketleri.

Görev 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>

Bu basit. inputÜst düzeydeki bir etiketle eşleşir ve istenen çıktıyla değiştirir.

Görev 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>

Bu, 2 özyinelemeli şablon loopve tanımlar spaces. loopparametreler ile ive pozisyondan başlayarak nistenen çıktıyı üretecektir . parametresi ile boşluk üretecektir .nispacesnn

Görev 3

Bunun için giriş <input><num>..</num><num>..</num></input>etiketleri olmalıdır .

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

Bu sadece gcdÖklid algoritmasını kullanan özyinelemeli bir kalıp .

2014 - CJam

CJam PPCG kullanıcısı aditsu tarafından yaratıldı ve Nisan 2014’te piyasaya sürüldü .

"Selam Dünya!" varyant

"CJam was made in 2014!"

CJam program sonunda yığının içeriğini otomatik olarak yazdırır

ASCII Art N

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

Kod açıklaması:

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

N'nin yüksekliğini / genişliğini STDIN ile giriş olarak alır. Burada çevrimiçi deneyin

GCD

l~{_@\%}h;

İki sayıyı STDIN üzerinden giriş olarak alır. Burada çevrimiçi deneyin

1990 - Haskell

Haskell popüler (ya da söylemeliyim: en popüler ?) Saf işlevsel bir dildir. Olağandışı değerlendirme modeli (varsayılan olarak, her şey tembel ya da teknik olarak katı değildir) ve şu anda hala en güçlü olanlar arasında yer alan Hindley-Milner tabanlı tip sistemiyle ana akımdan ayrılır.

Görev 1

main = putStrLn "Haskell was made in 1990!"

Görev 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, tüm sonsuz listeyi yazdır (kullanıcı iptal edene veya dünya bitene kadar ...)

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

...

Elbette, sonsuz listenin yalnızca bir öğesine erişerek bunlardan birine kolayca erişebilirsiniz:

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

Görev 3

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

1972 - ARA

Ve Fortran ve Cobol'un garip olduğunu düşündün. Bu çılgınlık!

Görev 1

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

INTERCAL'in giriş ve çıkış sistemini açıklamaya çalışmayacağım; sadece okumak bu ölürsün kalmayız.

Görev 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

Aman Allahım. Bu beni anlamak için biraz aldı. Etiket numaraları karışıktır ve bu nedenle bunu yansıtır. Birisi sormadığı sürece bunu açıklamaya çalışmayacağım.

Görev 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

Bu biraz daha basit. INTERCAL'in ... tuhaflığından dolayı, bunun gibi sayıları girmek zorundasınız:

THREE FIVE

Örneğin, 42 ve 16’nın GCD’sini almak için girerim:

FOUR TWO
ONE SIX

Ayrıca, rakamları Romen rakamlarıyla basar ... çünkü bu sizin için INTERCAL!

1967 - APL

1957'de Harvard Üniversitesi'nde Ken Iverson dizi manipülasyonu için matematiksel bir gösterim geliştirmeye başladı. 1960'larda, notasyonu IBM'de bir programlama dili haline geldi. İlk kısmi uygulama 1963'te kuruldu ve öğrencilere aşkın fonksiyonları öğretmek için bir lisede bile kullanıldı. Tam ve kullanışlı bir uygulama 1965 yılına kadar beklemek zorunda kaldı. İki yıl boyunca yalnızca IBM tarafından dahili olarak kullanıldı. 1967’de, IBM halka açık olan ve 1966’da bitmiş olan IBM 1130 bilgisayarında çalışan bir APL tercümanı yayımladı. Bunun için bir yıl seçmenin ne kadar zor olduğunu anlayabilirsiniz, ilk yıl olduğu için halka tam bir uygulama yapıldı. Eğer biri gerçekten aynı fikirde değilse, değiştirebilirim.

APL \ 360 kaynak kodu bir emülatör gibi çevrimiçi . Bu örnekleri test etmek için kullandığım şey bu. 1967'den kalmadır ve APL \ 1130 ile birlikte (yukarıda belirtilen IBM 1130 için), asıl orijinalidir. Beklendiği gibi, çok ilkel. Bu, herhangi operatörler küçük harfler gibi incelikler için destek vermeyen tek yerleşik fonksiyonları ile çalışır ve yerleşik fonksiyonlar dizisi çok seyrek (özellikle ∨olduğunu sadece or ve yok değil gibi çift gcd). Orijinal, tam bir açıklama burada mevcuttur , ancak sahip olduğum sürümün o belgeye göre tam olmadığını ⍎, diğerlerinin yanında olmadığını fark ettim .

Programları hem Unicode biçiminde (böylece okuyabilirsin) hem de orijinal kodlamada sağladım (bu sayede bunları emülatörün APL penceresine kesip yapıştırabilirsiniz).

İnanılmaz bir şekilde, bu programlar Dyalog, NARS2000 ve GNU APL'nin modern versiyonlarında (kodlama hariç) herhangi bir değişiklik yapmadan doğru çalışıyor. Sanırım taşınabilir APL yazmanın yolunu buldum: 1967 gibi yap!

Görev 1:

Unicode:

⎕←'APL WAS MADE IN 1967!'

APL \ 360:

L[Kapl was made in 1967ÝK

Görev 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'

Görev 3:

Bunu standart özyinelemeli yoldan çözdüm. Teoride, J cevabı gibi zekice ve dizi odaklı bir şeyler yapabilirsiniz; Bununla birlikte, pratikte, O (N) bellek kullanımı vardır ve hızlı bir şekilde Flower-Power-dönem zorluğunu ve yazılımı zorlar.

Unicode:

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

⎕←⎕ GCD ⎕

APL \ 360:

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

L[L gcd L

1996 - Ocaml

1996’yı dolduran birine günden fazla bekliyordum, bu yüzden Ruby’yi doldurabilirim. O zaman neden OCaml'i öğrenmiyorsun, haskell'e benziyor ...

Selam Dünya

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

Değişken dizeler!

GCD

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

Hayır ==ve ekleme mod, bu sevimli

2005 - Prelüd

Prelude olan kaynak kodu paralel olarak yürütülür ve birkaç "sesler" oluşan oldukça eğlenceli bir dil olduğunu ben gerçekten problem çözme keyfini . Kardeş dili ASCII gösterimi olması gerekiyordu Füg aslında kaynak kodu olarak .midi dosyaları alır ve sesler melodiler içinde aralıklarla olarak Prelude bulunan talimatları kodlar.

Prelude oldukça minimalist, ancak Turing tamamlandı (en az 2 ses kullanmanız şartıyla). Dediğim gibi, sesler (kod satırları) eşzamanlı olarak ve sütun sütununda yürütülür. Her ses, sonsuz sayıda sıfıra ayarlanan kendi yığınında çalışır. Prelude aşağıdaki talimatları desteklemektedir:

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

Bazı ek notlar:

• Sesler döngüseldir, bu nedenle ^üstteki ses alttan gelen seslerden kopyalanır (ve tersi).
• Birden fazla ?ve !aynı sütunda yukarıdan aşağıya doğru yürütülür.
• Gereğince dil şartname , ?ve !karşılık gelen karakter kodu ile okuma ve yazma karakter. Ancak, Python yorumlayıcısının ayrıca kodları kendi yerine basmak için bir anahtarı da vardır. Test amaçlı Aslında kullanıyorum değiştirilmiş bir versiyonunu da olabilir okunan numaraları yerine karakterleri. Ancak buradaki fikir birliği , sayısal girdi / çıktıların aslında bayt değerleri olarak verilebildiğinden, sayılarla ilgili geçerli programlar yapmak için bu değişikliklerin yapılmasına gerek yoktur.
• Eşleştirme (ve )aynı ses üzerinde olması gerekmez. Koşul için kullanılan ses her zaman( göründüğü yerdir . Bu nedenle, dikey konumu )tamamen alakasızdır.
• Prelude'nin eşzamanlı yürütülmesinin doğası gereği, a (ile aynı sütunda yer alan tüm komutlar , döngü başlamadan önce ve döngünün girilip girilmediğinden bağımsız olarak gerçekleştirilir. Benzer şekilde, )her bir yinelemenin sonunda, döngünün bu yinelemeden çıkıp çıkmayacağından bağımsız olarak, a ile aynı sütundaki herhangi bir komut uygulanır.

İlk önce size pek fazla yorum yapmadan üç programı göstereceğim. Aşağıda geniş açıklamalar bulabilirsiniz.

Programlar

"Selam Dünya!" varyant

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

Python yorumlayıcısını kullanıyorsanız, emin olun NUMERIC_OUTPUT = False.

ASCII Art N

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

Kullanım kolaylığı için, bu program girdiyi sayı olarak okumaktan yararlanır, ancak çıktı sayısal olmamalıdır. Eğer değiştirilmiş Python yorumlayıcısını kullanıyorsanız,

NUMERIC_INPUT = True
NUMERIC_OUTPUT = False

GCD

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

Bu en iyi şekilde tüm sayısal giriş / çıkışlarla kullanılır.

NUMERIC_INPUT = True
NUMERIC_OUTPUT = True

açıklamalar

"Selam Dünya!" varyant

Bu oldukça yalındır. Başarıyla tüm karakterler için karakter kodları oluşturmak için 3 ses kullanıyorum Prelude was made in 2005!. 8 + 9*8 = 80Karakter koduyla hesaplamaya başlıyorum P:

 9(1-)
 8 8+

Ondan sonra çoğunlukla sadece önceki karakter kodunu kopyalarım ve farkı diğerine ekler veya çıkarırım. İşte kod, ancak her !biri yazdırılan karakterle değiştirildi (ve _boşluklar ve %rakamlar için):

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

Nihai 55+!daha nazikçe diye, sırf bir satırsonu karakterini yazdırır.

Bir yan not olarak, seslerin sayısı bu görev için oldukça keyfidir, ancak 3 oldukça uygundur çünkü her sesin doğrudan diğer seslere doğrudan erişebileceği en büyük sayıdır.

ASCII Art N

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

5 sesle, bu kesinlikle şu ana kadar yazdığım en karmaşık programlardan biri. Sesler kabaca aşağıdaki amaçlara sahiptir:

1. Yalnızca N-1iç döngüde kullanılmak üzere depolanan bir yardımcı ses .
2. Bu, girişi okuyan “ana” sestir, önemli bir anahtar içerir ve ayrıca dış çevrimi (yani satırların üstündeki) içerir.
3. Bu, 32alanları rahatça basmak için a saklar .
4. Bu iç döngü (sütunların üzerinde olanı) içerir.
5. Bu 78kolayca yazdırmak için bir a saklar N.

Kod bölüm bölüm geçelim. İlk olarak, 32as -4 + 9*4ve 78as olarak yaratıyorum 6 + 9*8:

9(1-)
4-4+

6 8+

Şimdi bir tek yazdırdığımı Ngirişi okurken (biz her zaman bir ihtiyaç olduğundan) Nve saklanması N-1ve N-2ilk iki sesle:

      v2-
     ?1-

     v!

Sonra, şartlandırılmış bir "döngü" var N-1. Döngünün sonunda, ikinci ses her zaman azaltılır 0ve döngü ilk yinelemeden sonra çıkar. Yani aslında, bu sadece if(N > 1){...}. Döngüden sonra tek bir izleyen yeni satır basarız. Özetlemek için, şimdi aşağıdaki çerçeveye sahibiz:

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

Bu şartın içinde ilk sırayı tamamlamak için ilk N-2boşlukları ve tek olanı kullanırız ve Nayrıca N-1gelecekte kullanmak üzere ilk sese depolarız :

         (1-)v         
          v!  

             v!

Şimdi kodun gerçek eti. İlk olarak, N-1satırları basan bir dış döngü vardır . Her satır için, öncelikle bir yeni satır ve bir baskı N. Sonra, zaman veya döngü N-2ya da Ns yazdırarak döngüleri tekrar edeceğiz . Sonunda bir tane daha basalım N:

               1-55+!  

                v1-v!(               )v!
               v#

Son olarak, eğlenceli kısım: her satırı yazdırmak (ve Ndoğru pozisyonu almak ). Prelude'da gerçekten bir if / else yok, bu yüzden farklı sesler üzerinde iki döngü kullanarak kendim oluşturmak zorundayım. Koşul, iç ve dış döngü değişkenini çıkartarak kolayca elde edilebilir - 0yazdırmak Nistiyorsak, bir alan yazdırmak istiyorsak sıfır olmayan bir şey elde ederiz.

Prelude'deki if / else'in temel fikri ilgili değerin - "if" (veya sıfır olmayan) kodundan sonra bir döngü koymak ve hemen a tuşuna basarak çıkmanızdır 0. Başka bir seste, sıfır olmayan bir değer ve "if" döngüsünden sonra başka bir döngü elde edersiniz . "İf" döngüsü sırasında , "else" in yürütülmesini engellemek için diğer sesin üzerine sıfır koyarsınız. Sıfır değerlerin sıfır olmayan değerlerin üstüne itilmesi veya sıfırın altında bir sıfır olması durumunda basitçe sıfır olmayan değerin atılmaması konusunda bir miktar esneklik vardır, ancak genel fikir budur. İlgili sesi kullanmaya devam etmek istiyorsanız, daha sonra biraz temizlik yapmanız gerekebilir. Kod böyle görünüyor:

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

Ve bu kadar!

GCD

Bu, Öklid algoritmasının yinelemeli bir uygulamasıdır. Ancak Prelude'deki modulo biraz can sıkıcıdır, çünkü bir sayının pozitif mi yoksa negatif mi olduğunu kolayca kontrol edemezsiniz. Bu kod, bir süre önce yazdığım bir signum uygulamasından yararlanıyor . Yani kodun büyük bir kısmı sadece bir sayıya dönüşür , veya . Bu daha sonra kolayca ekleyerek veya çıkartarak pozitif veya negatif sayılar için bir koşul haline getirilebilir .-1011

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

Demek bu sefer dört tane sesimiz var. İlk ses basit bir bşekilde ana sonlandırma koşulunu izler ve içerir (yani, bdönüştüğünde döngü çıkar 0). İkinci ses , sonucu önceki ile değiştirmeden önce, aüç ve dört hesaplama seslerinin yardımı ile içerir . Sonunda, ne zaman yazdırır .a % bb!ab == 0

İlk önce signum kısmına bakalım :

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

Giriş numarası nbu seslerin ilkinde bulunur (tam programdaki ikinci ses). Sonuç alt seste sona erecektir. Diğer iki sesin boş olması beklenir (yani, sıfırlarla doldurulur). Eğer dikkat edin n == 0, daha sonra her iki döngüler atlanır ve alt ses hala içeren 0istediğimiz sadece ne.

nSıfır değilse , ilk küçük döngü girilir. Hemen çıkmak için sıfıra nbasarız, orta sese ve a'nın iki sesini 1alt sese koyarız . Şimdi temel fikir, kopyalarından birini sıfıra nindirinceye kadar diğer kopyasını azaltarak çoğaltmaktır n. Bunu yaparken 1, alttaki ses her zaman işaretini çevirir (bu kolaylıkla 0yığının altından çıkarılarak yapılır ). Bu, sayılardan biri sıfıra geldiğinde , alt sesin doğru işareti içereceği şekilde ayarlanmıştır .

Şimdi modülo çıkarılarak uygulanır bgelen asonuç negatif olana kadar. Bu olduğunda, bir tane bdaha ekleriz . Bu biraz:

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

Görev 2 için kullandığıma benzer olan alttaki if / else yapısına dikkat edin.

2007 - Kazı Kazan

Çizik , MIT tarafından eğitim amaçlı yapılan bir dildir. 5 senedir onunla çok ilgileniyorum; bundan sonra daha fazlası.

Bunların hepsi burada görülebilir .

Şu an çok acelem var ve snippet'leri daha sonra açıklayacağım. Umarım yine de açıklayıcı bir rol oynarlar.

Görev 1

Görev 2

Görev 3

1972 - C

Hepimiz C'yi biliyoruz, değil mi? C, Unix ile birlikte Bell Laboratuarlarında kuruldu. Unix büyük ölçüde C ile yazılmıştır. Tüm modern Unix türevleri hala büyük ölçüde C ile yazılmıştır. C'nin sözdizimi birçok, birçok programlama dilini etkilemiştir. Muhtemelen hala yeni gelişme için yaygın olarak kullanılan en eski programlama dilidir.

C'nin kendisi de bu listede yer almasını umduğum, B'nin soyundan. 'A' programlama dili yoktu: B, sıyrılan bir CPL olan BCPL'nin bir çeşididir. Bu dillerin hiçbiri hiç popüler değildi. Ancak, BCPL ilk "Merhaba Dünya" programının yazıldığı dildi. Bir başka ilginç gerçek B de vardı olduğunu /* */ve //yorumlarınızı, ancak C düştü //yorumlar. Daha sonra C99 standardına göre C'ye tekrar sokuldu.

Buradaki C programları, 1974'ten itibaren Unix V5 C derleyicisiyle test edildi. Bu bulabildiğim ve çalışabileceğim en eski C derleyiciydi ve bu programlar modern bir C derleyicide derlenmeyecek. (Yapılan değişikliklerden biri, mutasyon operatörlerinin +=eskiden olduğu gibi yazılmasıdır =+.)

#include <... >henüz yoktu. Standart kütüphanenin çoğunu da yapmadım. Kendi yazmam gerekiyordu atoi. Hangi kaynaklara izin verildiğini ve hangilerinin yapılamayacağını belirlemek için bazı V5 kaynak kodlarından geçtim. Kullandığım sürüm structs'yi içeren ilk sürümdü, ancak bunları kullanmadığımdan ve sözdizimi V7'ye (K&R C olarak) kadar çok fazla değişmemiş gibi görünüyor, bu daha önceki sürümlerle de işe yarayabilir.

Kodumu V5 kaynak kodunun kullandığı stilde yazmak için elimden geleni yaptım. (Yine de bu çok tutarlı değil.)

Bir emülatör olan Unix V5'e bağlantılar ve modern bir bilgisayarda çalışmasına ilişkin talimatlar için buraya bakın .

Görev 1

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

Görev 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]));
}

Görev 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 - İdris

İdris, bağımlı tiplerle elde edilebilecek son derece zorlu kanıt olanakları sunmanın yanı sıra, gerçek dünyadaki uygulamalar için pratik olarak uygulanabilir olduğunu vurgulayan, bağımlılık gösteren, saf ve işlevsel bir dildir.

Görev 1

module Main

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

Görev 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

Bu bir program değil, sadece iki boyutlu bir dizi olarak istenen harfi N üreten bir fonksiyondur (daha doğrusu bağımlı değer ).

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

Görev 3

module gcd

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

Adı seçmem gerektiğine dikkat edin gcd'çünkü gcdİdris başlangıcında tanımlandığı gibi.

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

2014 - Pyth

CJam'a sahip olduğumuz için, aynı zamanda tamlık için Pyth de olabilir :)

Pyth @isaacg tarafından Python'a derlenen bir golf dilidir . İşlemsel olması ve ön ek gösterimini kullanması çok önemlidir. Pyth ilk Haziran 2014'te ortaya çıktı .

"Selam Dünya!" varyant

"Pyth was made in 2014!

Bir Pyth programı bir dizgede bitiyorsa isteğe bağlı olan bir kapanış teklifi olmadığına dikkat edin.

ASCII Art N

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

Çevrimiçi deneyin . Eşdeğer Python:

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

Veya genişletilmiş (birinci ve üçüncü satırlar örtük):

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

Bu program Öklid algoritmasını kullanır ve yeni bir çizgiyle ayrılmış iki sayı alır. Çevrimiçi deneyin .

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

i.uQGCD için yerleşik kullanırsak, daha da kısadır. Bu eşittir print(gcd(*eval(input())))(giriş olarak virgülle ayrılmış iki sayı alarak).

1964 - Dartmouth TEMEL

BASIC , tasarım felsefesini kullanım kolaylığına vurgu yapan genel amaçlı, üst düzey bir programlama dili ailesidir. 1964 yılında, John G. Kemeny ve Thomas E. Kurtz, New Hampshire'daki Dartmouth College'da orijinal BASIC dilini tasarladı. Öğrencilerin fen ve matematik dışındaki alanlarda bilgisayar kullanabilmelerini sağlamak istedi.

1964’den itibaren BASIC’in bu kılavuzuna ve çalıştığı Darthmouth Time Sharing System’ın bu emülatörüne bakıyorum . Sunucu hala çalışır durumda, ancak ne yazık ki, bir hesaba kaydolmak imkansız görünüyor. Şimdilik bu programlar teorik olarak çalışmalı:

Görev 1

10 PRINT "BASIC WAS MADE IN 1964"
20 END

Görev 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

Gibi bir şey çıktı:

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

Girişin programın bir parçası olarak nasıl yazıldığına dikkat edin ( 70 DATA 5); READüstündeki talimat yolu var veri getirir. Dize bitiştirme yoktur, ancak kılavuzun 3.1 bölümü PRINTsonuçların çıktıdaki tablolanmış "bölgelere" nasıl yazıldığını açıklar .

Görev 3

Öklid algoritmasının yavaş versiyonu:

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

Çıkarılması:

2

2010 - WTFZOMFG

WTFZOMFG, Brainfuck'a dayalı ezoterik bir dildir. 2010 yılında Jay Songdahl tarafından yapılmıştır. "WTFZOMFG", "Bu İşlev Nedir? Zen, Kötü Amaçlı Dosya Gophers'ı Optimize Etti!" .

* Nix sistemleri için bir derleyici .

Görev 1

'WTFZOMFG was made in 2010!\n"

Görev 2

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

Açıklama:

Üzgünüm. Açıklama yazmakta iyi değilim.

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

Görev 3

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

Öklid algoritması. WTFZOMFG'nin mod komutları yoktur, bu yüzden d(bölmek), m(çarpmak) ve s(çıkarmak) kullanmak zorundayım .

2009 - Git

Go, Google tarafından geliştirilen bir programlama dilidir. Gelişme 2007'de başladı, ancak Go Kasım 2009'da açıklandı.

Go, özlülük, basitlik ve güvenliği vurgulayan C'den etkilenen, statik olarak yazılmış bir dildir.

Görev 1:

package main
import "fmt"

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

İlk satır kodun paketini bildirir. Tek bir satır basmak gibi basit bir örnek bile bir paketin parçası olmalıdır. Ve yürütülebilir her zaman denirmain .

Görev 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 oldukça özlü bir değişken bildirimine sahiptir ( i := 0aynıdır var i int = 0) ve derleyici türünü belirler. Bu genellikle dinamik dillerde daha yaygın olan bir özelliktir. Bu kısa gösterimi kullanarak, değişkenlere ( f := func(x int) int {/* Code */}) işlevler atamak ve Kapaklar oluşturmak gerçekten de kolaydır .

Görev 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))
}

Burada a, b = b, a%b, gerçekten güzel olan sözdizimini görebilirsiniz . Tam adını bilmiyorum, ama Python'da buna paket açma denir. Aynı şekilde bir işlevden ( func f() (int, string) { return 42, "Hallo"}) birden fazla değer döndürebilirsiniz .

Bu kodda gerçekleşen başka bir şey döngüdür. For döngüsü Go'daki tek döngüdür. While-döngüler ya da-while-döngüler yoktur. Ancak while döngüsü for condition {}veya sonsuz bir döngü için kolayca bir eşdeğer oluşturabilirsiniz for {}.

1991 - Python

Dil tarihi

1980'lerin sonunda, Guido van Rossum, Python'u bir hobi olarak tasarlamaya başladı. Adı Monty Python'un Uçan Sirki, Rossum'un hayranı olduğu bir İngiliz televizyon programı. İlk Python uygulaması 1989'da başladı ve 1991'de piyasaya sürüldü. Yıllar geçtikçe popülaritesini artırdı ve birçok bilgisayar dersi dersi için tercih edilen dil oldu.

"Selam Dünya!" varyant

print("Python was made in 1991!")

Girişin etrafındaki parantezleri not alın print. Bu sözdizimi Python 2'de çalışsa da, genellikle Python 2'de bu parantezleri çıkarırsınız. Bununla birlikte, Python 3'te zorunludurlar. Zach Gates tarafından önerildiği gibi, burada sunulan kodun sürümler arasında çalışmasını sağlamak için parantez içinde kullanılır.

ASCII Art N

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

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

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

İşlevler kullanılarak tanımlanır def. Dize bitiştirme +ve ile dize tekrarı kullanılarak gerçekleştirilir *.

GCD

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

Python'un yapılandırılmış boşluk gerektirdiğini unutmayın.

1968 - Algol 68

Algol 68, IFIP Çalışma Grubu 2.1 tarafından Algol 60'ın halefi olarak tanımlanmıştır.

Her şeyin bir değeri olduğu ifade odaklı bir dildir. Aynı zamanda, herhangi bir yapıyı herhangi bir şekilde kullanabileceğiniz ortogonaldir. Bu, ifadelerin, örneğin bir ödevin RHS'sinde ve LHS'sinde olabileceği anlamına gelir.

Tüm kontrol yapıları, kısaltılmış bir biçime ve ifadeleri kullanan uzun bir biçime sahiptir. Ayrıca operatörlerin tanımlarına da izin verir.

Dilin hedefleri şöyledir:

ALGOL 68 tasarımının temel amaçları ve ilkeleri:

• Açıklamanın eksiksizliği ve açıklığı
• Ortogonal tasarım,
• Güvenlik,
• verim
• Statik mod kontrolü
• Kipten bağımsız ayrıştırma
• Bağımsız derleme
• Döngü optimizasyonu
• Temsiller - en küçük ve daha büyük karakter kümelerinde

Bu programlar , dilin tam bir uygulaması olan Algol 68 Genie tercümanı ile test edilmiştir .

Modern programcıların farklı bulabileceği bazı özellikler, boş ifadelere izin verilmemesidir. Sadece ;her yere ekleyemezsin . SKIPAçıkça hiçbir şey yapmamak istiyorsanız, bu ifadeyi kullanmanız gerekir. Aynı zamanda eşzamanlı programların kodlanmasına çok kolay bir şekilde izin verdi. Algol 68 ayrıca, özellikle, esac , od , fi vb. Gibi sonlandırıcı olarak anahtar kelimeleri geriye doğru kullanmıştır .

Dil , örneğin, koyu harflerle anahtar kelimeleri temsil eden birçok yazı tipini ve örneğin italik harfleri tanımlayan kodları yazmak için kullanılan bir gösterime sahipti . O zamanlar ve muhtemelen hala, hiçbir derleyici tasarımın bu özelliğini uygulamadı. Dil, vuruş modlarını kullanarak programların birkaç farklı somut temsiline izin verdi . Bu, programların 1960'larda bilgisayarlarda bulunabilecek gibi sınırlı karakter setleri kullanılarak hazırlanmasına izin verdi. Aşağıdaki gibi temsil edilecek kısa bir program parçasını göz önünde bulundurun:

eğer ben < 0 sonra atlamak fi

Bu, temel vuruş modunda bir derleyici için hazırlanabilir :

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

Gelen nokta çekme düzeltme modu bu olacaktır:

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

In case çekme düzeltme modu bu olacaktır:

IF i < 0 THEN SKIP FI

Derleyici uygulamalarından biri üzerinde çalıştığımdan, sadece yıllarca programladığım için bu dile büyük düşkünlüğüm var.

Görev 1

print (("Algol 68 1968'de yapıldı!", newline )

Burada dikkat edilmesi gereken nokta çift parantezdir. Bunun nedeni, baskının , her tür birliğin değişken uzunluklu dizisi olan tek bir argüman alan bir işlev olmasıdır. İç parantez, dizi yapıcısıdır. Bu, polimorfizmin bu türden güçlü bir dille nasıl işlendiğidir.

Vuruş modunda:

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


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

Görev 2

     int n ; ( n )
     okundu ; için i den 1'e kadar n do için j den 1'e kadar n do ¢ biz kısaltılmış bir IF tümcesi kullanmak buraya ¢ baskı ((( j = 1 VEYA j = i YA j = n |                     "N" |                     ""                ))) od ; Yazdır (( newline)
    
         
              
              

              


         
     ))
     od

Vuruş modunda:

 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

Görev 3

     ¢ biz Algol 68 kendi operatörleri tanımlayabilir ¢
     op % = ( int bir , b ) int :
          (( B = 0 |
               a
          |
               b % ( bir mod b )
          ));
     int i , j ; (( i , j ))
     oku ; Yazdır (( i % j , newline ))
    

Vuruş modunda:

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

"StriNg Odaklı ve SymBOlic Dil". İlk başta görünüşe göre Sembolik İfade Tercümanı olarak adlandırılan “SEXI”, 1960'ların çağındaki kızların işlerini gönderirken kızarmalarını önlemek için değiştirilmeleri gerekti. Gerçek hikaye.

Bu, yerel olarak dizelerle ve desenlerle ilgilenebilecek ilk dillerden biriydi. Nitekim, SNOBOL'un ilk versiyonunda dizgenin tek veri türü olduğu görüldü . Matematik daha sonra ayrıştırma ile yapıldı. İlk uygulama IBM 7090'da yapıldı. Çoktan gitmiş görünüyor, en azından bulamadım. Ne buldunuz oldu nitelendirerek orijinal kağıt yanı sıra modern bilgisayar üzerinde çalışabilir Java SNOBOL3 tercüman, .

İlk SNOBOL'un hemen hemen sadece desen eşleştirmesi ve temel aritmetiği vardı. Daha sonra SNOBOL 3, fonksiyonlar ekledi ve I / O’yu değiştirdi, ancak aksi halde geriye dönük olarak uyumlu kaldı. SNOBOL 4, sözdizimini değiştirdi ve oradan , desen eşleştirmesini koruyan ancak neredeyse "normal" bir programlama dili gibi gözüken Simge haline geldi .

Yazdığım programlar, yalnızca orijinal belgede açıklanan işlevleri kullanır, bu nedenle, Java yorumlayıcısının bunları çalıştırabilmesi için SNOBOL3 stilinde yaptığım G / Ç hariç, orijinal SNOBOL ile çalışması gerekir. Kağıttan farkı, SNOBOL1'in özel bir SYSdeğişkenle desen eşleştirmesi kullanması , oysa SNOBOL3'ün giriş ve çıkış değişkenleri kullanması gibi görünüyor:

• Giriş:
  • 1 SYS .READ *DATA*
  • 3 DATA = SYSPPT
• Çıktı:
  • 1 SYS .PRINT 'A STRING' AND VARIABLES
  • 3 SYSPOT = 'A STRING' AND VARIABLES

Bu değişikliklerin yapılması size 'gerçek' SNOBOL 1 kazandırmalıdır. Tabii ki, o zaman koşamazsınız.

Görev 1

START   SYSPOT = 'SNOBOL WAS MADE IN 1962!'

Görev 2

Bu matematik, string işleme ve akış kontrolünü gösterir. SNOBOL3 EQeşitliği kontrol etmek gibi faydalı fonksiyonlara sahiptir ; Orijinal SNOBOL kullanmadı, ben de kullanmadım.

* 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     

Görev 3

İlk olarak, sıkıcı olanı. Unutulmaması gereken tek şey çeklerden daha küçük olan ve dizeye yönelik SNOBOL'un gerçekte ne kadar olduğunu gösteren: (B - A) '-'"BA'nın sonucu eksi içeriyor mu?" Anlamına geliyor. SNOBOL3 de yapabilir LE(B,A), ancak SNOBOL 1 yapamadı (en azından kağıt bundan söz etmiyor).

* 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

Elbette, tamamen dizeleri ve desen eşleştirmeyi temel alan bir dile sahipseniz, gerçekte eşleştirme ve değiştirme işlevini kullanmamak bir utanç olacaktır. Dolayısıyla, işte bu, birliğe dönüşme rutinleri de dahil olmak üzere, tekdere dayalı GCD’lerden biridir.

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

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


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

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

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

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

FIN     START

2012 - TypeScript

TypeScript, Microsoft tarafından geliştirilen ve tutulan ücretsiz ve açık kaynaklı bir programlama dilidir.

Ana hedefi: Herhangi bir tarayıcı. Herhangi bir ev sahibi Herhangi bir işletim sistemi Açık kaynak. Ekim 2012'de yayınlandı.

Merhaba TypeScript

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

ASCII Sanatı

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

çevrimiçi denemek ve screencast .

2011 - Dart

Dart, Google tarafından geliştirilen, Javascript’in (javascript’e derlendiğine göre) değiştirilen bir Açık Kaynak programlama dilidir. GOTO konferansında 2011 yılında Google tarafından tanıtıldı.

"Selam Dünya!" Varyant:

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

ASCII Art N:

Bruteforce yöntemi, 0 (n²) değerinde çalışır, ancak dev bir sayı kullanmıyorsanız, bu gerçekten önemli olmamalıdır.

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

Snap'ten taşınan basit Euclid yöntemi! yukarıdaki örnek.

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

Rust, Mozilla Research tarafından geliştirilen genel amaçlı, çoklu paradigma ve derlenmiş bir programlama dilidir. Saf işlevsel, eşzamanlı oyuncu, zorunlu-işlemsel ve nesne yönelimli stilleri destekleyen "güvenli, eşzamanlı, pratik bir dil" olacak şekilde tasarlanmıştır. Vikipedi

Görev 1

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

Task2

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

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

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

Açıklama:

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

Sadece dikey (sol ve sağ |) ve çapraz ( \) baskıya dikkat eder

Görev 3

Euclidean_algorithm'in basit uygulaması

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 - Çörek MC

Muffin MC , Franck Porcher ( http://franckys.com ) tarafından Şubat 2015 ortasındaki zorunlulukları aşan bir zorunluluk aracı olan zorunluluk dışı bir zorunluluktur. Tahiti moda markası için Prestashop tabanlı bir tüccar sitesiyle ilgili tüm envanterle ilgili işlemleri kontrol etmek ve yönlendirmek için tek ön uç denetleyici olarak kullanılacak e-tablo: Mutiny Tahiti ( http://mutinytahiti.com - yakında başlatıldı).

Muffin MC için kullanılan bir kısaltmadır MU minik K unctional F lexible İÇİNDE hat M acro C ommand dile.

Gereksinimlerimizi karşılamak için, Muffin MC'nin temel özellikleri, yineleyiciler , tembel değerlendirme , çok işlevliler , yaylı ürünler gibi esnek ve verimli 1. sınıf yerleşik semantik yapılar etrafında tasarlanmıştır .

Muffin MC , köklerini (pragmatik) işlevsel programlamada, FLisp ve Perl'de çeker. Özyinelemeyi (herhangi bir optimizasyon olmadan) tamamen destekler, dinamik olarak yazılır ve dinamik olarak kapsamlanır (sığ ciltleme). Kullanıcılarına yalnızca bir veri yapısı sunar, temel veri türleri atomları (atomlar, dizeler, sayılar) dışında: listeler!

Muffin MC list anlambilim (tür) power set anlambilim ödünç , yani:

1. Tüm Muffin MC operasyonları muhtemelen boş bir liste oluşturur.
2. Herhangi bir bireysel liste öğesine erişim her zaman o öğeden yapılmış bir tek değer listesi verir (bunu bir tekil olarak düşünün).
3. Boş liste, listedeki nötr elemandır.

Bununla uzlaşmak için, aşağıdakiler yardımcı olabilir:

• Bir liste, listenin en büyük kardinaliteye sahip olan güç setinin bir öğesi olarak görselleştirebilir.
• Bir listenin elementini, listenin o elementten yapılan singleton olan güç setinin elemanı olarak görselleştirin.
• Boş bir listeyi boş set olarak görselleştirin; yani, boş kümenin güç kümesinin tek elemanı.

Bu nedenle, boş bir liste öğesine erişmek bir hata değil boş listeyi verir! Gerçekten, Muffin MC birçok geleneksel işlemin anlamını bu şekilde genişleterek mümkün olduğunca az hata atmaya çalışıyor.

Görev 1

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

#(...)Değerlendirilmemiş bir argüman listesine bir işlev uygulamak için Muffin MC makro komutu, burada yerleşik işlev sayPerl'den ödünç alındı.

#(say 1 2 3 ...) işlevsel olarak aynıdır map {say $_} (1,2,3,...)

Görev 2

Fonksiyonu tanımlayın 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()en kısa çalışma şekli (88 bayt):

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

• =(var val...)Bir değişkeni tanımlamak veya yeniden atamak için Muffin MC makro komutudur.

• $(var)Bir değişkenin değerine erişmek için Muffin MC makro komutudur. Aynı $(v1 v2 ...)anda birçok değişkene erişmek için formu doğal olarak kabul eder .

• =(* var1 val1 var2 val2 ...)Muffin MC macro komutunun =(...)paralel atamalar ile başa çıkma uzantısıdır .

• Değişkenler _1, _2, ... dinamik olarak kapsamalıdır (sığ ciltleme mekanizması) ve otomatik olarak fonksiyonun argümanlarına bağlanmak üzere ayarlanır. Perl5'ten ödünç alınmış, sistem değişkenleri #(argüman sayısı) ve @(argüman listesi) de otomatik olarak ayarlanır.

• İşlevler, yalnızca herhangi bir sayıda Muffin MC deyimine bağlı değişkenlerdir .

Bu ilginç çözüm, iki doğal Muffin MC yerleşik özelliğini bir araya getirmekten geliyor :

1. Çörek MC I(...) makro komut, daha sonra fonksiyonel formu ile birlikte kullanıldığında bisiklet-yineleyici tanımlamak #(my-iterator want-number-of-values),

2. Çörek MC dize ürünün yapısı, herhangi bir dizge, doğal değişken enterpolasyon, bir uzantısı "F1 F2 F3..."F, I s, ya çörek olan MC dize hazır veya çörek MC makro komutu (aka fonksiyonel formlar), olduğu kadar çok dizeleri üretecek ürün kardinal (F1) x kardinal (F2) x ... ile verilir.

Örneğin, 2 değeri tutan xa değişkeni verildiğinde, a ve b diyor ve y, 3 değeri içeren başka bir değişken diyor, 1 2 3, sonra dizenin değerlendirilmesi, bu sırada "x=$(x) y=$(y))"6 farklı değer üretecek:

• "X = ay = 1"
• "X = ay = 2"
• "X = ay = 3"
• "X = = 1 tarafından"
• "X = = 2 tarafından"
• "X = = 3 ile"

Bu, MUTINY projesinin Muffin MC'nin tasarladığı son derece arzulanan özelliklerinden biridir .

Koş!

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

O nasıl çalışır

Algoritmamız aşağıdakilere dayanmaktadır:

Ascii-art (n) 'a yapılan çağrı, {n = 2p + 1 | p tamsayı, p> = 0}, üretilecek sanat, n, en sol ve en sağdakilerin sabit olduğu ve her zaman aynı olduğu n karakterlerinden oluşan n karakterleri içerir: 'N'. Bu, yalnızca orta dizgelerin üretilmesinde sorunu azaltmaya izin verir. Örneğin, n = 5 verildiğinde, her biri n-2 karakterinden oluşan 5 orta dizgiyi üretmeye çalışırız (daha iyi görselleştirme için boşluğu '_' ile değiştirdik):

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

• Bu tür orta dizgiler, 4 element dizisi ('_' '_' '_' 'N')üzerinde 3'lü 5 grup halinde bisiklete binerek kolayca üretilebilir ; n verildiğinde, fonksiyonun girişi, bu sekans n-2 karakterlerinden '_'sonra bunu karakterden oluşur 'N'. Bu sekans üzerinde bisiklete binmek başka bir şey gerektirmez, sekansı bir Muffin MC I(sequence) yerleşik yineleyicisine (ilk değer sekansı üzerinde sonsuza dek dolaşan bir yineleyici) içine yerleştirmekten başka bir şey gerekmez .

• Daha sonra basitçe n-2 uzunluğundaki orta dizgileri üretiyoruz, yineleyicimizden beklenen orta dizgeyi üretmek için bir araya getirilen sıradaki n-2 değerlerini (n - 2 karakter) vermesini istiyoruz.

• N orta dizeleri, n sonuçlarının toplanması için bir harita kullanılarak (n-2 karakterlerin dizeleri) yukarıdaki işlemin n katı tekrarlanarak üretilir.

• Biz başka güçlü Muffin kullanmak MC yerleşik yapısı, yani dize ürünü n nihai dizeleri üretmek için,: "N#(map...)N".

• Ve bu kadar !

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

Görev 3

Fonksiyonu tanımlayın gcd():

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

gcd()Var gerçek kısa bir şekilde (37 bayt - 2bytes Rodolvertice kazanabil-)

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

Koş!

#(gcd 225 81)

9 verir.

Bu kadar.

Güzel oyun için ve muhtemelen ilginize teşekkür ederiz. Dil, oynamak, kullanmak veya hatta genişletmek isteyen herkes için kullanılabilir. Sadece sor ve gönderdiğim için mutlu olacağım.

Şerefe

Franck

PS. Muffin MC'nin şu anki uygulaması Perl5'te. Kaynak kod, yorumlar da dahil olmak üzere, yaklaşık 2000 satırlık modern Perl'dir ve uygulamalı Muffin MC yapıları ve anlambilimi öğrenmek için harika olan regresyon olmayan bir test paketi ile birlikte gelir .