Bei dieser Herausforderung erledigen die Benutzer abwechselnd drei recht einfache Codierungsaufgaben in Programmiersprachen, die älter werden dürfen.

Für die erste Antwort muss eine Programmiersprache verwendet werden, die im Jahr 2015 erstellt wurde. Wenn mindestens eine Antwort aus einer 2015-Sprache vorliegt, können für die Antworten Programmiersprachen verwendet werden, die im Jahr 2014 erstellt wurden. Ebenso sind Antworten mit Sprachen aus 2013 nicht zulässig bis es mindestens eine Antwort für 2014 gibt.

Im Allgemeinen ist die Verwendung einer Programmiersprache aus dem Jahr Y erst zulässig, wenn eine Antwort in einer Sprache aus dem Jahr Y + 1 eingereicht wurde. Die einzige Ausnahme ist Y = 2015.

Das Jahr Ihrer Sprache finden

Um diese Frage zu beantworten, müssen Sie das Jahr kennen, in dem Ihre Programmiersprache erstellt wurde. Dies ist natürlich ein subjektiver Begriff; Einige Sprachen wurden über mehrere Jahre hinweg entwickelt, und viele Sprachen werden jedes Jahr aktualisiert. Lassen Sie das Jahr, in dem eine Sprache "hergestellt" wurde, das erste Jahr sein, in dem eine Implementierung für diese Sprache in der Öffentlichkeit erschien.

Zum Beispiel Python wurde „in gemacht“ 1991 , obwohl seine Entwicklung seit 1989 im Gang gewesen, und die Version 1.0 wurde erst 1994 veröffentlicht.

Wenn dieses Jahr immer noch subjektiv ist, verwenden Sie einfach Ihren gesunden Menschenverstand, um das am besten geeignete Jahr zu wählen. Lassen Sie sich nicht von leichten Meinungsverschiedenheiten über die Wahl des Jahres hinreißen. Bitte geben Sie einen Link zu einer Quelle an, aus der hervorgeht, wann Ihre Sprache erstellt wurde.

Verschiedene Versionen oder Standards einer Programmiersprache (z. B. Python 1, 2, 3) werden mit demselben Anfangsjahr als dieselbe Sprache gezählt.

Wenn das Jahr Ihrer Sprache also nicht 2015 ist, können Sie Ihre Antwort erst einreichen, wenn eine Antwort eingereicht wurde, deren Jahr das Jahr vor Ihrem ist.

Wenn bereits eine gültige Antwort mit demselben Jahr wie dem Ihren vorhanden ist, können Sie antworten. Es spielt keine Rolle, ob Ihre Sprache früher oder später im Jahr entwickelt wurde.

Aufgaben

Sie müssen die Aufgaben 1 bis 3 ausführen. Aufgabe 0 ist optional.

Diese Aufgaben wurden mehr oder weniger ausgewählt, um drei wichtigen Aspekten der Programmierung zu entsprechen: Ausgabe (Aufgabe 1), Schleifen (Aufgabe 2) und Rekursion (Aufgabe 3).

Aufgabe 0 - Sprachverlauf (optional)

Schreiben Sie mindestens einen Absatz, in dem die Geschichte der von Ihnen gewählten Programmiersprache erklärt wird: Wer hat sie entwickelt, warum, wie usw. Dies ist besonders empfehlenswert, wenn Sie persönlich dabei waren, als die Sprache entstand, und vielleicht sogar eine Rolle bei ihrer Entwicklung gespielt haben. Zögern Sie nicht, persönliche Anekdoten über die Auswirkung der Sprache auf Sie oder Ihre Arbeit oder ähnliches zu erzählen.

Wenn Sie zu jung sind, um ohne viel Recherche viel über die Geschichte Ihrer Sprache zu wissen, sollten Sie älteren Benutzern eine Notiz hinterlassen, in der Sie angeben, dass sie Ihren Beitrag bearbeiten und einen Verlauf aus erster Hand hinzufügen können.

Aufgabe 1 - "Hallo, Welt!" Variante

Schreiben Sie ein Programm, das gedruckt wird

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

zum Standard-Ausgabebereich Ihrer Sprache (Standard für die neuesten Sprachen).

Wenn die Sprache beispielsweise Python wäre, wäre die Ausgabe:

Python was made in 1991!

Aufgabe 2 - ASCII Art N

Schreiben Sie ein Programm, mit dem der Benutzer eine ungerade positive Ganzzahl eingeben kann (Sie können davon ausgehen, dass die Eingabe immer gültig ist), und drucken Sie einen ASCII-Kunstbuchstaben N aus, der mit dem Zeichen erstellt wurde N.

Wenn die Eingabe 1 ist, ist die Ausgabe:

N

Wenn die Eingabe 3 ist, ist die Ausgabe:

N N
NNN
N N

Wenn die Eingabe 5 ist, ist die Ausgabe:

N   N
NN  N
N N N
N  NN
N   N

Wenn die Eingabe 7 ist, ist die Ausgabe:

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

Das Muster geht so weiter. Die Ausgabe kann nachgestellte Leerzeichen enthalten.

Aufgabe 3 - GCD

Schreiben Sie ein Programm, mit dem der Benutzer zwei positive ganze Zahlen eingeben kann (Sie können davon ausgehen, dass die Eingabe immer gültig ist), und geben Sie den größten gemeinsamen Teiler aus . Dies ist definiert als die größte positive Ganzzahl, die beide Zahlen teilt, ohne einen Rest zu hinterlassen. Sie kann leicht mit dem Euklidischen Algorithmus berechnet werden .

Beispiele:

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

Sie können eine integrierte Funktion verwenden, aber versuchen herauszufinden, ob sie in der ersten Version Ihrer Sprache vorhanden war. Wenn nicht, versuchen Sie es nicht.

Regeln

• Sie können mehrmals antworten, aber für jede neue Antwort muss eine Sprache verwendet werden, die mindestens 5 Jahre vor der Sprache in Ihrer letzten Antwort erstellt wurde. Wenn Sie also mit einer Sprache von 2015 geantwortet haben, konnten Sie erst wieder antworten, wenn Sprachen für 2010 zulässig sind. Wenn Sie mit einer 2010-Antwort beginnen, können Sie keine 2015-Antwort als zweite Antwort festlegen, da 2015 nicht vor 2010 liegt.
• Wenn möglich, schreiben Sie Ihren Code so, dass er in der allerersten Version Ihrer Sprache (oder in einer möglichst alten Version) funktioniert hätte. (Dies ist keine Voraussetzung, da es schwierig sein kann, alte Compiler / Interpreter für einige Sprachen zu finden.)
• Stellen Sie das Posten einer bereits geposteten Sprache ein, es sei denn, die gepostete Antwort weist erhebliche Fehler auf oder Sie führen die Aufgaben auf eine ganz andere Weise aus.
• Golfen Sie Ihren Code ist in Ordnung, aber nicht erforderlich.
• Ein abschließender Zeilenumbruch in der Ausgabe eines Programms ist in Ordnung.
• Für die Aufgaben 2 und 3 sollten alle Eingabewerte unter einem vernünftigen Maximum wie 2 ¹⁶ funktionieren (mindestens 256).
• Ihre Sprache muss vor dem Absenden dieser Frage existiert haben.
• Sehr alte Programmiersprachen können andere Ein- und Ausgabeformen haben als wir heute denken. Das ist okay. Führen Sie die Aufgaben so gut wie möglich im Kontext Ihrer Sprache aus.

Wertung

Die Punktzahl Ihrer Einreichung ist:

upvotes - downvotes + (2015 - languageYear) / 2 

Somit wird die Stimmenzahl für jedes Jahr vor 2015 um 0,5 erhöht, was älteren Sprachen zugute kommt. Die Einsendung mit der höchsten Punktzahl gewinnt.

Antwortliste

Das folgende Stapel-Snippet listet alle gültigen Antworten nach ihrem Sprachjahr auf.

Sie müssen Ihren Beitrag mit dieser Markdown- Zeile beginnen, um sicherzustellen, dass er korrekt aufgelistet ist:

#[year] - [language name]

Zum Beispiel:

#1991 - Python

Der Name der Sprache kann sich in einem Link befinden (es wird derselbe Link in der Antwortliste sein):

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

Antworten, die diesem Format nicht entsprechen oder ein Jahr haben, das noch nicht zulässig ist, oder von einem Benutzer stammen, der in den letzten 5 Jahren bereits geantwortet hat, werden als ungültig markiert.

<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 ist eine Sprache, die 2013 von Zach Bruggeman entwickelt wurde. Es ist nichts weiter als ein Syntaxersatz für Javascript, um es so zu lesen wie die internen Monologe des memetischen Shiba Inus.

Hallo doge

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

ASCII Art

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

Retina ist eine auf Regex basierende Programmiersprache, die ich geschrieben habe, um bei PPCG-Herausforderungen mit regex-only-Antworten mithalten zu können, ohne den unnötigen Aufwand zu haben, die Regex in einer bestimmten Hostsprache aufzurufen. Netzhaut ist Turing-vollständig. Um dies zu beweisen, habe ich einen 2-Tag-Systemlöser sowie Regel 110 implementiert . Es ist in C # geschrieben und unterstützt daher sowohl die .NET-Variante (standardmäßig) als auch die ECMAScript-Variante (über ein Flag).

Die Netzhaut kann in mehreren Modi betrieben werden, aber der für Berechnungen relevanteste (und der für das vollständige Turing) ist der Ersetzungsmodus. Im Ersetzungsmodus geben Sie Retina eine gerade Anzahl von Quelldateien. Diese werden dann gepaart, wobei der erste von jedem Paar ein regulärer Ausdruck und der zweite ein Ersatz ist. Diese werden dann der Reihe nach ausgeführt, wobei die Eingabe schrittweise bearbeitet wird. Dem regulären Ausdruck kann auch eine Konfiguration vorangestellt werden (mit `). Die wichtigste Option (die Retina Turing vervollständigt) ist +, dass Retina den Ersatz in einer Schleife anwendet, bis sich das Ergebnis nicht mehr ändert. In den folgenden Beispielen verwende ich auch ;, was die Ausgabe auf Zwischenstufen unterdrückt.

In jeder der folgenden Übermittlungen wird jede Zeile in einer separaten Quelldatei abgelegt. (Alternativ können Sie die neue -sOption verwenden und alle Zeilen in eine einzelne Datei einfügen.) Leere Dateien / Zeilen werden als dargestellt <empty>. Dateien / Zeilen, die ein einzelnes Leerzeichen enthalten, werden als dargestellt <space>.

Die Erklärungen sind ziemlich lang, deshalb habe ich sie an das Ende des Beitrags verschoben.

Die Programme

"Hallo Welt!" Variante

<empty>
Retina was made in 2015!

ASCII Art N

Dies setzt voraus, dass STDIN mit einem Zeilenumbruch abgeschlossen wird.

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

Dies setzt voraus, dass STDIN nicht mit einem Zeilenumbruch abgeschlossen wird.

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

Erklärungen

"Hallo Welt!" Variante

Das ist ziemlich trivial. Es braucht keine Eingabe (dh eine leere Zeichenkette), passt zu nichts und ersetzt es durch Retina was made in 2015!. Man kann es auch für willkürliche Eingaben verwenden, indem man das Muster [\s\S]*zum Beispiel durch ersetzt . Das würde STDIN schlürfen und alles durch die Ausgabe ersetzen.

ASCII Art N

Das hat ziemlich viele Stufen. Die Idee ist, die Eingabe in unär zu konvertieren, einen N x N-Block von Ns zu erstellen und dann zwei Dreiecke "herauszuschneiden". Lassen Sie uns die einzelnen Phasen durchgehen. Denken Sie daran, dass ;nur Zwischenausgaben unterdrückt werden, +der Ersatz jedoch in einer Schleife angewendet wird.

;`^
#

Ganz einfach: Stellen Sie a #vor die Eingabe. Dies wird als Markierung bei der Konvertierung nach Unary verwendet.

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

Dies wandelt eine Ziffer in eine unäre um. Es nimmt die bereits konvertierten Ziffern (\d*)und wiederholt sie 10 Mal. Dann wird die nächste Ziffer verwendet und die entsprechende Anzahl von Ziffern angehängt. Der tatsächliche Wert der Ziffern ist zu diesem Zeitpunkt unerheblich. Wenn das #Ende der Zahl erreicht ist, stimmt der reguläre Ausdruck nicht mehr überein, und die Konvertierung wird durchgeführt. Als Beispiel wird die Nummer 127als verarbeitet

#127
1#27
111111111122#7
1111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111227777777#

Die letzte Zeile enthält genau 127 Ziffern.

;`#
<empty>
;`\d
N

Zwei einfache Stufen, die das beseitigen #und dann alle Ziffern in konvertieren N. Im Folgenden werde ich die Eingabe 7als Beispiel verwenden. Jetzt haben wir also

NNNNNNN

Die nächste Stufe

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

NErsetzt jede Zeichenfolge durch die gesamte Zeichenfolge (denken Sie daran, dass sie eine abschließende neue Zeile enthält) und entfernt auch die abschließende neue Zeile selbst. Somit wird die einzelne Zeile in ein quadratisches Gitter umgewandelt:

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN

Nun das obere Dreieck. Zuerst beginnen wir damit, das N in der unteren rechten Ecke in ein Leerzeichen zu verwandeln:

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

Der Lookahead stellt sicher, dass wir das richtige ändern N. Das gibt

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNN N
NNNNNNN
NNNNNNN

Und nun

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

ist ein regulärer Ausdruck, der mit einem übereinstimmt, Nder sich über oder in der oberen linken Ecke eines Leerzeichens befindet und dieses durch ein Leerzeichen ersetzt. Da das Ersetzen wiederholt wird, handelt es sich im Wesentlichen um eine Überflutung, die den 3. Oktanten vom Anfangsraum in mehr Räume verwandelt:

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

Und schließlich wiederholen wir dasselbe mit dem unteren Dreieck, verwenden jedoch ein anderes Zeichen, damit die bereits vorhandenen Räume keine falsche Überflutung verursachen:

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

setzt den Samen:

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

Dann

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

macht die Flutfüllung.

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

Und schlussendlich

S
<space>

Wandelt diese Sin Leerzeichen um und wir sind fertig:

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

GCD

GCD in Unary ist eigentlich sehr trivial mit Regex. Das meiste davon besteht aus der Umwandlung von Dezimal nach Unär und von Unär nach Dezimal. Dies könnte kompakter gemacht werden, aber dies ist kein Code-Golf, also ...

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

Diese Stufen sind im Wesentlichen die gleichen wie oben, außer dass beide Eingabenummern konvertiert werden und das Ergebnis 1s anstelle von Ns verwendet (nicht, dass es wichtig ist). Wenn also die Eingabe 18 24wäre, würde dies produzieren

111111111111111111 111111111111111111111111

Jetzt

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

ist die gesamte GCD-Berechnung. Wir 1gleichen einen gemeinsamen Divisor ab, indem wir eine Anzahl von s erfassen und dann Rückverweise verwenden, um sicherzustellen, dass beide Zahlen durch Wiederholen dieser Zeichenfolge (und sonst nichts) geschrieben werden können. Aufgrund der Funktionsweise von Backtracking in der Regex-Engine (dh das .+ist gierig) ergibt sich automatisch immer der größte gemeinsame Divisor. Da die Übereinstimmung die gesamte Zeichenfolge abdeckt, schreiben wir einfach die erste Erfassungsgruppe zurück, um unsere GCD zu erhalten.

Endlich die Umrechnung von Unär zu Dezimal ...

;`$
#:0123456789

Fügen Sie der Zeichenfolge einen Marker #, einen Begrenzer :und alle Ziffern hinzu. Dies ist erforderlich, da Sie in einer Regex-Ersetzung keine neuen Zeichen bedingt erzeugen können. Wenn Sie eine bedingte Ersetzung wünschen, müssen Sie die Zeichen aus der Zeichenfolge selbst ziehen, damit wir sie dort ablegen.

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

Dies ist das Gegenteil der früheren unären Expansion. Wir finden das größte Vielfache von 10, das in die aktuelle Zeichenfolge passt. Dann wählen wir die nächste Ziffer basierend auf dem Rest und teilen das Vielfache durch 10, während wir den Marker durch die Ziffern bewegen.

#|:.*
<empty>

Und zum Schluss noch ein Bereinigungsschritt, um den Marker, das Trennzeichen und die Hilfsziffern zu entfernen.

2013 - Schnapp !

Schnapp ! ist eine Sprache, die auf Scratch basiert und an der Berkeley University entwickelt wurde. Es ist ein Upgrade auf Scratch mit erstklassigen Daten und benutzerdefinierten Blöcken (Funktionen). Wie Scratch basiert es nicht auf Text, sondern auf visuellen "Blöcken", die zusammenpassen.

Schnapp ! , geschrieben in JavaScript, ist der Nachfolger von BYOB, das in Squeak Smalltalk geschrieben wurde. Schnapp ! wurde im März 2013 als Beta für den öffentlichen Verbrauch freigegeben .

Schnapp ! ist eigentlich keine esoterische Sprache. Es wird als Programmiersprache für den AP CS-Kurs von Beauty and Joy of Computing (BJC) in Berkeley und anderen verwendet.

Ich half beim Testen und so.

Variante "Hallo Welt"

ASCII Art "N"

Dies verwendet die Stdlib für einige der Blöcke.

Ziemlich einfaches Looping hier. Nimmt eine Eingabe entgegen. Dann addieren wir einfach alles und sagen es (Ergebnis für n = 5):

Ich habe mir hier die Freiheit genommen, nur 2 statt 1 Leerzeichen zu verwenden, weil Snap! sagt nichts in Monospace.

GCD

Der euklidische Algorithmus ist nicht sehr schnell, funktioniert aber und ist ziemlich einfach. (Entschuldigung, ich habe einen Tippfehler im Blocknamen gemacht. Jetzt habe ich die Registerkarte geschlossen, ohne zu speichern. Es muss nur bleiben.)

Diese Funktionsdefinition erzeugt dann diesen Block:

2007 - LOLCODE

Sprachgeschichte

LOLCODE wurde 2007 von Adam Lindsay, einem Forscher an der Lancaster University, entwickelt. Die Syntax basiert auf den von Cheezburger, Inc. verbreiteten lolcats-Memen.

"Hallo Welt!" Variante

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

Werte werden als Zeichenketten (YARNs) von stdin mit gelesen GIMMEH. Sie können durch Multiplizieren mit 1 in numerische Werte (NUMBRs) umgewandelt werden.

Die Werte werden mit auf Standard gedruckt VISIBLE. Standardmäßig wird eine neue Zeile angehängt, die jedoch durch Hinzufügen eines Ausrufezeichens unterdrückt werden kann.

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 Führt eine String-Verkettung durch.

1982 - PostScript

PostScript ist eine Sprache zum Erstellen von Vektorgrafiken und Drucken.

Adobe wurde 1982 gegründet und ihr erstes Produkt war PostScript. Die Sprache wurde in Druckern verwendet: Die Befehle werden vom Drucker interpretiert, um ein Rasterbild zu erstellen, das dann auf die Seite gedruckt wird. Es war eine sehr verbreitete Komponente von Laserdruckern bis weit in die 1990er Jahre. Auf dem Drucker ist die CPU-Belastung offensichtlich recht hoch, und da Computerprozessoren immer leistungsfähiger wurden, war es sinnvoller, die Rasterung auf dem Computer durchzuführen als auf dem Drucker. PostScript ist auf Verbraucherdruckern weitgehend verschwunden, obwohl es auf vielen weiteren High-End-Druckern noch vorhanden ist.

Der Standard, der PostScript ersetzte, ist ein wenig bekanntes Format namens PDF.

Als ich mit dem Programmieren anfing, war PostScript aus der Mode gekommen, aber ich habe während meines Studiums ein wenig gelernt, um Dokumente für TeX zu erstellen. Es war ganz anders als in anderen Programmiersprachen, die ich verwendet hatte (Reverse-Infix-Notation, Stapeln, Drucken auf einer Seite anstelle einer Konsole), aber es war schön, diese alte Sprache für ein bisschen Spaß abzuwischen.

Da es sich bei PostScript um eine Drucksprache handelt, ist es sinnvoller, sie zum Drucken zu verwenden und dann eine Ausgabe an die Konsole zu senden.

Aufgabe 1

/Courier findfont
12 scalefont
setfont
newpath

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

Die ersten Zeilen bilden eine Zeichenfläche. Anschließend movetoweist der Befehl PS an, an einer bestimmten Position zu zeichnen, und showdruckt die Zeichenfolge auf der Seite aus. Beachten Sie, dass Klammern eine Zeichenfolge in PostScript und keine Anführungszeichen markieren.

Aufgabe 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

Ich habe eine Funktion zum Zeichnen von "ASCII art" N geschrieben, aber PostScript-Funktionen können keine Argumente verwenden. Stattdessen legen Sie Ihre Argumente auf den Stapel und entfernen sie dann wieder. Das ist die /x exch defLinie.

Ein Beispiel: Angenommen, der Stapel ist 8 9 2. Zuerst geben wir den Namen /xin den Stapel ein, der Stapel ist also 8 9 2 /x. Der exchOperator tauscht die beiden Stapelwerte aus, der Stapel ist also jetzt 8 9 /x 2. Dann werden defdie beiden obersten Stapelwerte eingefügt und definiert /x, dass der Wert verwendet werden soll 2. Der Stapel ist jetzt 8 9.

Als ich anfing, PostScript zu verwenden, fand ich das etwas verwirrend. Ich hatte über den Stapel als theoretisches Konzept gelesen, aber dies war das erste Mal, dass ich ihn in der Praxis verwendete.

Der Rest der Funktion ist ein Zeichencode: Beginnen Sie in der unteren rechten Ecke und füllen Sie jeweils eine Zeile von links nach rechts nach diagonal aus.

Aufgabe 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

Auch hier habe ich eine Form von Euclids Algorithmus verwendet, aber ich hatte vergessen, dass PostScript einen eingebauten Modulo-Operator hat, also musste ich meinen eigenen schreiben. Dies hat sich als nützliche Erinnerung an die Einschränkungen der Stack-basierten Programmierung erwiesen. Meine erste Implementierung von modulobasierte auf Rekursion:

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

Das ist in Ordnung, bis Sie versuchen, dies auszuführen, wenn xes groß und yklein ist (z. B. 5689 und 2). Sie können nur bis zu 250 Elemente auf dem Stapel haben, und so habe ich die Stapelgrenze weit überschritten. Hoppla. Ich musste an das Zeichenbrett zurückkehren.

Der GCD-Code selbst ist ziemlich einfach. Aber genau wie Funktionen keine Argumente annehmen können, haben sie auch keine Rückgabewerte. Stattdessen müssen Sie das Ergebnis auf den Stapel verschieben, wo es später von einem anderen Benutzer abgelegt werden kann. Das ist, was die Zeilen aund b a gcdtun: Wenn sie die Auswertung beendet haben, verschieben sie den Wert in den Stapel.

Wenn Sie den gesamten Code in ein Dokument einfügen und drucken, sieht die Ausgabe folgendermaßen aus:

2009 - > <>

Inspiriert von Befunge ist> <> (Fisch) eine esoterische, stapelbasierte 2D-Sprache, dh der Programmfluss kann nach oben, unten, links oder rechts erfolgen. Die ursprüngliche Version von> <> enthielt Multithreading [und ]erstellte und beendete Threads. Aus Gründen der Einfachheit wurden diese Anweisungen jedoch dahingehend geändert, dass neue Stacks erstellt bzw. entfernt wurden.

Den aktuellen offiziellen Dolmetscher für> <> finden Sie hier . Leider ist die Verbindung zum alten Interpreter im Esolang-Wiki unterbrochen.

"Hallo Welt!" Variante

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

Beachten Sie, wie die Zeichenfolge rückwärts geschrieben wird -> <> verfügt technisch gesehen nicht über Zeichenfolgen. Der einzige Datentyp ist eine seltsame Mischung aus char, int und float. "Schaltet die Zeichenfolgenanalyse um und schiebt jedes Zeichen auf den Stapel, bis ein Abschluss erreicht "ist.

Die zweite Hälfte des Codes schiebt dann die Länge des Stapels l, prüft, ob sie Null ist ?!und wenn ja, wird das Programm beendet ;. Andernfalls wird der Befehlszeiger weitergeht, mit der Oberseite des Stapels auszugeben , obevor die Ausführung bb+0., die den Zeiger teleports zu positionieren , (22, 0)kurz bevor die l, eine Schlaufe entsteht.

ASCII Art N

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

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

   \                                                         <   /

Mit Abstand zur Klarheit. Sie können versuchen , diese auf die neuen Online - Interpreter heraus hier und sehen Sie den Zeiger Anweisung geht herum und herum - nur nicht vergessen , eine Nummer im „Initial Stack“ Textbox eingeben. Wenn Sie mit dem Python-Interpreter arbeiten, verwenden Sie das -vFlag, um den Stack zu initialisieren, z

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

Für dieses Programm setzen wir die Eingabe nin das Register mit &und drücken eine 0, die wir ifür "Iterationen" aufrufen . Der Rest des Programms besteht aus einer riesigen Schleife, die so abläuft:

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

Dann wiederholen wir die Schleife von Anfang an.

Die Pfeile ^>v<ändern die Richtung des Programmflusses und die Spiegel geben /\die Richtung des Programmflusses wieder.

GCD

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

Hier ist ein Beispiel, wie ein Golf> <> Programm aussehen könnte. Sie können dies erneut im Online-Interpreter versuchen (geben Sie z. B. zwei durch Kommas getrennte Werte in das Feld "Anfangsstapel" ein 111, 87) oder indem Sie das -vFlag des Python-Interpreters verwenden, z

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

Dieses Programm verwendet den euklidischen Algorithmus. Hier ist ein GIF, das ich zuvor vorbereitet habe:

Beachten Sie, dass> <> toroidal ist. Wenn der vBefehl unten links ausgeführt wird, bewegt sich der Befehlszeiger nach unten, umläuft ihn und wird oben wieder angezeigt.

Bearbeiten: Durch die vollständige Ausführung des Codes von rechts nach links konnte @randomra drei Bytes mit rasieren

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

Ich schätze, ich habe nicht genug Golf gespielt :)

2012 - Element

Dies ist eine Sprache, die ich Anfang 2012 erfunden habe, um eine einfache Golfsprache zu sein. Damit meine ich, dass es kaum bis gar keine Bedienerüberlastung gibt. Die Bediener sind auch einfacher und weniger zahlreich als die meisten modernen Golfsprachen.

Die interessantesten Merkmale dieser Sprache sind ihre Datenstrukturen. Es gibt zwei Stapel und einen Hash, die zum Speichern von Informationen verwendet werden.

Der m-Stapel ist der Hauptstapel, in dem arithmetische und die meisten anderen Operationen stattfinden. Wenn Daten eingegeben oder gedruckt werden, werden sie an dieser Stelle abgerufen oder abgerufen.

Der C-Stack ist der Kontrollstack. Hier findet die Boolesche Arithmetik statt. Die Spitzenwerte des C-Stacks werden von If- und While-Schleifen als Bedingung verwendet.

Im Hash werden Variablen gespeichert. Das ;bzw. ~Speichern und Abrufen von Daten aus dem Hash.

Element ist eine sehr schwach typisierte Sprache. Es nutzt Perls Fähigkeit, Zahlen frei als Zeichenfolgen zu interpretieren und umgekehrt.

Wenn ich schon dabei bin, kann ich auch die gesamte Dokumentation für die Sprache einbinden. Den originalen Interpreter für 2012, geschrieben in Perl, finden Sie hier . Update: Ich habe eine benutzerfreundlichere Version erstellt, die Sie hier finden .

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 \

Aufgabe 1 - Text drucken

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

Einer der schwierigeren Teile der Sprache ist das Fehlen von Zeichenkettenbegrenzern, weshalb in dieser Zeichenkette Escapezeichen erforderlich sind. Der `am Ende druckt den String.

Aufgabe 2 - ASCII Art N

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

Hier werden Sie Zeuge einiger Stapelmanipulationen. Um die Formatierung der Erklärung zu vereinfachen, ersetze ich die Zeilenumbrüche durch ein Lund das Leerzeichen durch ein 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

Nachdem ich diese Antwort extrem getestet hatte, fand ich eine 39-Byte-Lösung, obwohl sie viel komplizierter ist.

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

Aufgabe 3 - GCD

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

Dies ist eine stapelbasierte Methode.

__                 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

Sprachgeschichte

Julia wurde 2012 von Jeff Bezanson, Stefan Karpinski und Viral Shah entwickelt, während Jeff am Massachussets Institute of Technology (MIT) studierte und von Professor Alan Edelman beraten wurde. Sie waren motiviert von dem Wunsch nach einer Programmiersprache, die unter anderem Open Source, schnell und dynamisch war und gleichzeitig in einer Vielzahl von Anwendungen benutzerfreundlich war. Das Produkt war Julia, ein neuer Ansatz für das Hochleistungsrechnen in der Wissenschaft.

"Hallo Welt!" Variante

println("Julia was made in 2012!")

Das Drucken auf STDOUT in Julia ist ganz einfach!

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

Der Code ist aus Gründen der Lesbarkeit eingerückt, Julia legt jedoch keine Einschränkungen für Leerzeichen fest.

GCD

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

Das letzte, was in der Funktion aufgeführt ist, wird implizit zurückgegeben.

1988 - Mathematica

Oder soll ich es Wolfram-Sprache nennen ?

Aufgabe 0

Der Schöpfer von Mathematica ist Stephen Wolfram, der Gründer und CEO von Wolfram Research. Vor der Entwicklung von Mathematica war er Physiker. Da es in der Physik eine Menge algebraischer Berechnungen gab, wurde er ein Benutzer von Macsyma .

Wolfram promovierte 1979, als er 20 Jahre alt war. Er glaubte, er brauche ein besseres CAS als Macsyma, um Physik zu machen, und begann, SMP (das "Symbolische Manipulationsprogramm") zu schreiben . Die erste Version von SMP wurde 1981 veröffentlicht. SMP war der Vorgänger von Mathematica. Obwohl es einen tiefen Einfluss auf Mathematica hatte, wurde keiner seiner Codes jemals für Mathematica verwendet.

1986 beschloss Wolfram, ein "ultimatives Rechensystem" zu schreiben. Er begann 1986 mit dem Schreiben des Codes und gründete 1987 Wolfram Research. Schließlich wurde Mathematica 1.0 am 23. Juni 1988 veröffentlicht.

Ich habe Mathematica 1.0 nicht gefunden. Tatsächlich hatte Mathematica 1.0 weder eine Windows- noch eine Linux-Version. Aber ich habe Mathematica 2.0 auf einer chinesischen Website gefunden. Es kann weiterhin unter Windows XP ausgeführt werden.

Aufgabe 1

Print["Mathematica was made in 1988!"]

Oder einfach:

"Mathematica was made in 1988!"

Aufgabe 2

In der heutigen Mathematica können wir schreiben:

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

Genau wie Julia und R ist dies eine Matrixlösung. In Mathematica können Sie eine dünne Matrix mithilfe des Mustervergleichs definieren.

Wurde SparseArrayjedoch in Mathematica 5.0 eingeführt, sodass wir es in Mathematica 1.0 nicht verwenden können.

Hier ist eine Lösung, die in Mathematica 1.0 funktioniert:

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

Wir können nicht schreiben, f[i_, 1 | i_ | n] = "N"weil Alternativeses in Mathematica 2.0 eingeführt wurde.

Aufgabe 3

Wir können nur die eingebaute Funktion verwenden:

gcd = GCD

Oder wir können die Definition der GCD verwenden:

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

Oder wir können das LCM verwenden , obwohl LCM üblicherweise aus GCD berechnet wird:

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

Oder wir können den euklidischen Algorithmus mit Pattern Matching verwenden:

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

Oder als anonyme Funktion:

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

Alle oben genannten Funktionen wurden in Mathematica 1.0 eingeführt.

1999 - XSLT

Das World Wide Web Consortium (W3C) hat XSLT zur Umwandlung von XML in HTML, Text usw. erstellt. In den folgenden Beispielen wird davon ausgegangen, dass die Eingabe in <input>..</input>Tags eingeschlossen ist.

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

Dieser ist einfach. Es entspricht einem inputTag auf der obersten Ebene und ersetzt es durch die gewünschte Ausgabe.

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

Dieser definiert 2 rekursive Vorlagen loopund spaces. loopmit Parametern iund nerzeugt die gewünschte Ausgabe für n, beginnend an der Position i. spaceswith parameter nerzeugt nLeerzeichen.

Aufgabe 3

Die Eingabe hierfür muss in <input><num>..</num><num>..</num></input>Tags erfolgen.

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

Dies ist nur eine rekursive Vorlage gcd, die den euklidischen Algorithmus verwendet.

2014 - CJam

CJam wurde von PPCG-Benutzer aditsu erstellt und wurde um April 2014 veröffentlicht .

"Hallo Welt!" Variante

"CJam was made in 2014!"

CJam druckt den Inhalt des Stapels am Ende des Programms automatisch aus

ASCII Art N

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

Code Erklärung:

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

Nimmt die Höhe / Breite von N als Eingabe über STDIN. Probieren Sie es hier online aus

GCD

l~{_@\%}h;

Übernimmt die beiden Zahlen als Eingabe über STDIN. Probieren Sie es hier online aus

1990 - Haskell

Haskell ist eine beliebte (oder sollte ich sagen: die beliebteste ?) Reine Funktionssprache. Es hebt sich vom Mainstream ab durch sein ungewöhnliches Bewertungsmodell (standardmäßig ist alles faul oder technisch nicht streng) und durch sein auf Hindley-Milner basierendes Typensystem, das auch jetzt noch zu den leistungsstärksten auf dem Markt zählt.

Aufgabe 1

main = putStrLn "Haskell was made in 1990!"

Aufgabe 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, drucke die ganze unendliche Liste (bis der Benutzer abbricht oder die Welt untergeht ...)

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

...

Natürlich können Sie leicht zu einem dieser Elemente gelangen, indem Sie auf nur ein Element der unendlichen Liste zugreifen:

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

Aufgabe 3

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

1972 - INTERCAL

Und Sie dachten, Fortran und Cobol wären komisch. Das ist verrückt!

Aufgabe 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

Ich werde nicht versuchen, das Ein- und Ausgabesystem von INTERCAL zu erklären. lesen gerade dies und hoffen , dass Sie nicht sterben.

Aufgabe 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

Gute Güte. Das hat mich ein bisschen gekostet. Die Beschriftungsnummern sind ein Durcheinander und spiegeln dies wider. Ich werde nicht versuchen, dies zu erklären, es sei denn, jemand fragt.

Aufgabe 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

Das ist ein bisschen einfacher. Wegen der ... Verrücktheit von INTERCAL müssen Sie die Zahlen folgendermaßen eingeben:

THREE FIVE

Um beispielsweise die GCD von 42 und 16 zu erhalten, würde ich Folgendes eingeben:

FOUR TWO
ONE SIX

Es druckt auch die Zahl in römischen Ziffern ... denn das ist INTERCAL für Sie!

1967 - APL

1957 begann Ken Iverson an der Harvard University mit der Entwicklung einer mathematischen Notation für die Array-Manipulation. In den 1960er Jahren wurde seine Notation bei IBM zu einer Programmiersprache entwickelt. Die erste Teilimplementierung entstand 1963 und wurde sogar an einer High School verwendet, um Schüler über transzendentale Funktionen zu unterrichten. Eine vollständige, brauchbare Implementierung musste bis 1965 warten. Zwei Jahre lang wurde sie nur intern von IBM verwendet. 1967 veröffentlichte IBM einen APL-Interpreter für den IBM 1130-Computer, der 1966 fertiggestellt worden war. Sie können verstehen, wie schwierig es ist, ein Jahr dafür zu wählen, aber ich denke, es sollte 1967 sein. Da dies das erste Jahr ist, wurde der Öffentlichkeit eine vollständige Implementierung zur Verfügung gestellt. Wenn jemand wirklich anderer Meinung ist, könnte ich es ändern.

Der Quellcode für APL \ 360 ist online , ebenso wie ein Emulator. Dies ist, was ich verwendet habe, um diese Beispiele zu testen. Es stammt aus dem Jahr 1967 und ist zusammen mit APL \ 1130 (für die oben genannte IBM 1130) mehr oder weniger das wahre Original. Wie erwartet ist es sehr primitiv. Es fehlt die Unterstützung für Feinheiten wie Kleinbuchstaben, alle Operatoren arbeiten nur mit eingebauten Funktionen, und die Menge der eingebauten Funktionen ist sehr spärlich (insbesondere ∨ist nur or und nicht doppelt so groß gcd). Die vollständige Originalbeschreibung finden Sie hier . Mir ist jedoch aufgefallen, dass die Version, die ich hatte, in Bezug auf dieses Dokument nicht vollständig ist und ⍎unter anderem fehlt .

Ich habe die Programme sowohl im Unicode-Format (damit Sie sie lesen können) als auch in der ursprünglichen Codierung (damit Sie sie ausschneiden und in das APL-Fenster des Emulators einfügen können) bereitgestellt.

Unglaublicherweise laufen diese Programme in modernen Versionen von Dyalog, NARS2000 und GNU APL korrekt und ohne Änderungen (mit Ausnahme der Codierung). Ich habe also den Weg gefunden, tragbare APL zu schreiben: Tu einfach so, als wäre es 1967!

Aufgabe 1:

Unicode:

⎕←'APL WAS MADE IN 1967!'

APL \ 360:

L[Kapl was made in 1967ÝK

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

Schritt 3:

Ich habe dies auf die übliche rekursive Weise gelöst. Theoretisch könnten Sie etwas Cleveres und Array-orientiertes tun, wie die Antwort J; In der Praxis hat dies jedoch eine Speichernutzung von O (N) und überfordert schnell die Hardware und Software der Flower-Power-Ära.

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

Ich habe mehr als einen Tag darauf gewartet, dass jemand 1996 füllt, damit ich Ruby ausfüllen kann. Nun, warum lernst du dann nicht OCaml?

Hallo Welt

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

Veränderbare Saiten!

GCD

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

Nein ==und Infix mod, das ist süß

2005 - Vorspiel

Prelude ist eine sehr unterhaltsame Sprache, deren Quellcode aus mehreren "Stimmen" besteht, die parallel ausgeführt werden und in denen ich sehr gerne Probleme löse . Es soll die ASCII-Darstellung der Schwestersprache Fugue sein , die tatsächlich MIDI-Dateien als Quellcode verwendet und die im Prelude enthaltenen Anweisungen als Intervalle in den Melodien der Stimmen codiert.

Das Präludium ist ziemlich minimalistisch und dennoch vollständig (vorausgesetzt, Sie verwenden mindestens 2 Stimmen). Wie gesagt, die Stimmen (Codezeilen) werden gleichzeitig Spalte für Spalte ausgeführt. Jede Stimme bearbeitet einen eigenen Stapel, der mit einer unendlichen Anzahl von Nullen initialisiert wird. Prelude unterstützt die folgenden Anweisungen:

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

Einige zusätzliche Hinweise:

• Die Stimmen sind zyklisch, sodass ^die obere Stimme von der unteren Stimme kopiert wird (und umgekehrt).
• Mehrere ?und !in derselben Spalte werden von oben nach unten ausgeführt.
• Gemäß der Sprachspezifikation , ?und !lesen und schreiben Zeichen mit dem entsprechenden Zeichencode. Der Python-Interpreter verfügt jedoch auch über einen Schalter im Code, mit dem die Zahlen selbst gedruckt werden können. Zu Testzwecken verwende ich tatsächlich eine modifizierte Version, die auch Zahlen anstelle von Zeichen lesen kann . Es besteht jedoch Einigkeit darüber, dass die numerische Eingabe / Ausgabe tatsächlich als Bytewert angegeben werden kann. Daher sind diese Änderungen nicht erforderlich, um gültige Programme für den Umgang mit Zahlen zu erstellen.
• Matching (und )müssen nicht mit der gleichen Stimme sein. Die für die Bedingung verwendete Stimme ist immer diejenige, bei der die (angezeigt wird. Die vertikale Position der )ist daher völlig irrelevant.
• Aufgrund der Art der gleichzeitigen Ausführung von Prelude wird jeder Befehl in derselben Spalte wie a (nur einmal ausgeführt, bevor die Schleife beginnt, und unabhängig davon, ob die Schleife betreten wird. Ebenso wird jede Anweisung in derselben Spalte wie a )am Ende jeder Iteration ausgeführt, unabhängig davon, ob die Schleife nach dieser Iteration beendet wird.

Ich werde Ihnen zuerst die drei Programme zeigen, ohne viel zu kommentieren. Nachfolgend finden Sie ausführliche Erläuterungen.

Die Programme

"Hallo Welt!" Variante

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

Wenn Sie den Python-Interpreter verwenden, stellen Sie dies sicher 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#

Zur Vereinfachung der Verwendung bietet dieses Programm die Möglichkeit, Eingaben als Zahlen zu lesen, die Ausgabe darf jedoch nicht numerisch sein. Wenn Sie also den modifizierten Python-Interpreter verwenden, legen Sie fest

NUMERIC_INPUT = True
NUMERIC_OUTPUT = False

GCD

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

Dies wird am besten mit allen numerischen Ein- / Ausgängen verwendet, z

NUMERIC_INPUT = True
NUMERIC_OUTPUT = True

Erklärungen

"Hallo Welt!" Variante

Das ist ziemlich einfach. Ich benutze 3 Stimmen, um nacheinander die Zeichencodes für alle Zeichen in zu generieren Prelude was made in 2005!. Ich beginne mit dem Rechnen 8 + 9*8 = 80, das ist der Zeichencode von P:

 9(1-)
 8 8+

Danach kopiere ich meistens nur den vorherigen Zeichencode und addiere oder subtrahiere die Differenz zum nächsten. Hier ist der Code, wobei jedoch jeder !durch das Zeichen ersetzt wird, das gedruckt wird (und _für Leerzeichen und %für die Ziffern):

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

Das Finale 55+!druckt eine abschließende Newline, nur weil es schöner ist.

Als Randnotiz ist die Anzahl der Stimmen für diese Aufgabe ziemlich willkürlich, aber 3 ist ziemlich praktisch, weil es die größte Anzahl ist, bei der jede Stimme direkt auf die andere Stimme zugreifen kann.

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#

Mit 5 Stimmen ist dies definitiv eines der komplexesten Programme, die ich bisher geschrieben habe. Die Stimmen haben ungefähr die folgenden Zwecke:

1. Nur eine Helferstimme, die N-1zur Verwendung in der inneren Schleife gespeichert wird.
2. Dies ist eine Art Hauptstimme, die Eingaben liest, einen wichtigen Schalter enthält und auch die äußere Schleife (dh die über den Zeilen) enthält.
3. Dies speichert ein 32, um Leerzeichen bequem zu drucken.
4. Dies enthält die innere Schleife (die über den Spalten).
5. Hier können Sie 78bequem Ns drucken .

Lassen Sie uns den Code Teil für Teil durchgehen. Erstens bin ich die Schaffung der 32so -4 + 9*4und 78so 6 + 9*8:

9(1-)
4-4+

6 8+

Jetzt drucke ich eine einzelne N(weil wir immer eine brauchen), während ich die Eingabe Nund Speicherung lese N-1und N-2in den ersten beiden Stimmen:

      v2-
     ?1-

     v!

Als nächstes gibt es eine "Schleife", die auf konditioniert ist N-1. Am Ende der Schleife wird die zweite Stimme immer auf reduziert 0, und die Schleife wird nach der ersten Iteration beendet. Also im Wesentlichen nur das if(N > 1){...}. Nach der Schleife drucken wir eine einzelne abschließende Newline. Zusammenfassend haben wir jetzt das folgende Framework:

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

Innerhalb dieser Bedingung werden die ersten N-2Leerzeichen und ein einzelnes Nfür die Vervollständigung der ersten Zeile eingefügt und N-1die erste Stimme für die zukünftige Verwendung gespeichert :

         (1-)v         
          v!  

             v!

Nun das wahre Fleisch des Codes. Erstens gibt es eine äußere Schleife, die N-1Zeilen druckt . Für jede Zeile drucken wir zuerst eine neue Zeile und eine N. Dann wiederholen wir die N-2Zeiten und drucken entweder Leerzeichen oder Ns (dazu später mehr). Und zum Schluss drucken wir noch einen N:

               1-55+!  

                v1-v!(               )v!
               v#

Zum Schluss der lustige Teil: Drucken jeder Zeile (und Abrufen der Nrichtigen Position ). Im Prelude gibt es eigentlich kein Wenn und Aber, also muss ich es selbst mit zwei Loops auf verschiedenen Stimmen bauen. Die Bedingung kann leicht durch Subtrahieren der inneren und äußeren Schleifenvariablen erhalten werden - wir erhalten, 0wenn wir drucken möchten, Nund etwas ungleich Null, wenn wir ein Leerzeichen drucken möchten.

Die Grundidee eines if / else im Prelude besteht darin, eine Schleife nach dem entsprechenden Wert (dem "if" - Code (oder einem Code ungleich Null)) zu setzen und ihn sofort durch Drücken von a zu beenden 0. Bei einer anderen Stimme behalten Sie einen Wert ungleich Null und eine weitere Schleife nach der "if" -Schleife bei. Während der "if" -Schleife setzen Sie eine Null auf diese andere Stimme, um zu verhindern, dass das "else" ausgeführt wird. Es gibt eine gewisse Flexibilität, ob Sie Nullwerte auf Werte ungleich Null verschieben oder einfach den Wert ungleich Null verwerfen, wenn sich darunter eine Null befindet. Dies ist jedoch die allgemeine Idee. Möglicherweise müssen Sie auch nachträglich eine Bereinigung vornehmen, wenn Sie weiterhin die entsprechende Stimme verwenden möchten. So sieht der Code aus:

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

Und das ist es!

GCD

Dies ist "nur" eine iterative Implementierung des euklidischen Algorithmus. Aber Modulo im Prelude ist ein bisschen nervig, vor allem, weil man nicht leicht überprüfen kann, ob eine Zahl positiv oder negativ ist. Dieser Code verwendet eine Signum- Implementierung, die ich vor einiger Zeit geschrieben habe . Dh ein großer Teil des Codes stellt sich nur eine Zahl in -1, 0oder 1. Dies kann dann leicht durch Addieren oder Subtrahieren in eine Bedingung für positive oder negative Zahlen umgewandelt werden 1.

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

Wir haben dieses Mal also vier Stimmen. Die erste Stimme verfolgt einfach die Hauptbeendigungsbedingung bund enthält sie (dh die Schleife bwird beendet, wenn sie wird 0). Die zweite Stimme enthält aund mit Hilfe der Stimmen drei und vier Berechnungen a % b, bevor das Ergebnis mit der vorherigen ausgetauscht wird b. Schließlich werden die !Abzüge awann b == 0.

Schauen wir uns zuerst den Signum- Teil an:

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

Die eingegebene Nummer nbefindet sich auf der ersten dieser Stimmen (die zweite Stimme im vollständigen Programm). Das Ergebnis landet auf der untersten Stimme. Es wird erwartet, dass die anderen beiden Stimmen leer sind (dh mit Nullen gefüllt sind). Beachten Sie, dass n == 0dann beide Loops übersprungen werden und die unterste Stimme immer noch 0genau das enthält , was wir wollen.

Wenn nungleich Null ist, wird die erste kleine Schleife eingegeben. Wir drücken eine Null, um es sofort zu verlassen, legen zwei Kopien nauf die mittlere Stimme und eine 1auf die untere Stimme. Jetzt besteht die Grundidee darin, eine der Kopien von zu nerhöhen, während die andere von nzu verringern ist, bis eine von ihnen Null erreicht. Währenddessen 1kippt die Stimme auf der unteren Seite die ganze Zeit ihr Vorzeichen (was einfach durch Subtrahieren von 0darunter auf dem Stapel erfolgt). Dies ist so eingestellt, dass die unterste Stimme das richtige Vorzeichen enthält , wenn eine der Zahlen Null erreicht.

Nun wird Modulo durch Subtrahieren bvon implementiert, abis das Ergebnis negativ ist. Wenn das passiert, fügen wir noch einen hinzu b. Das ist das bisschen:

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

Beachten Sie die if / else-Konstruktion unten, die der für Aufgabe 2 verwendeten ähnelt.

2007 - Kratzer

Scratch ist eine Sprache, die vom MIT für Bildungszwecke entwickelt wurde. Ich bin seit 5 Jahren sehr damit beschäftigt. dazu später mehr.

Alle diese können hier eingesehen werden .

Ich bin gerade sehr gehetzt und werde die Schnipsel später erklären. Hoffentlich sind sie selbsterklärend.

Aufgabe 1

Aufgabe 2

Aufgabe 3

1972 - C

Wir wissen alle über C Bescheid, nicht wahr? C wurde bei Bell Labs zusammen mit Unix erstellt. Unix wurde größtenteils in C geschrieben. Alle modernen Unix-Derivate sind noch größtenteils in C geschrieben. Die Syntax von C hat viele, viele Programmiersprachen beeinflusst. Es ist wahrscheinlich die älteste Programmiersprache, die für Neuentwicklungen noch immer weit verbreitet ist.

C selbst ist ein Nachkomme von B, von dem ich hoffe, dass es auch in dieser Liste auftaucht. Es gab keine Programmiersprache 'A': B ist eine Variante von BCPL, die wiederum eine reduzierte CPL ist. Keine dieser Sprachen war jemals sehr beliebt. BCPL war jedoch die Sprache, in der das erste "Hello World" -Programm geschrieben wurde. Eine andere interessante Tatsache ist, dass B sowohl /* */als auch //Kommentare hatte, aber C die //Kommentare fallen ließ . Sie wurden später mit dem C99-Standard wieder in C eingeführt.

Die C-Programme hier wurden mit dem Unix V5 C-Compiler aus dem Jahr 1974 getestet. Dies war der älteste C-Compiler, den ich finden und zum Laufen bringen konnte, und diese Programme lassen sich auf einem modernen C-Compiler nicht kompilieren. (Eine der vorgenommenen Änderungen ist, dass früher Mutationsoperatoren +=geschrieben wurden =+.)

#include <... >existierte noch nicht. Viel von der Standardbibliothek auch nicht. Ich musste meine eigenen schreiben atoi. Ich habe einen Teil des V5-Quellcodes durchgesehen, um herauszufinden, welche Dinge erlaubt waren und welche nicht. Die Version, die ich verwendet structhabe, enthielt zuerst s, aber da ich diese nicht verwendet habe und die Syntax sich bis V7 (als K & R C) offenbar nicht wesentlich geändert hat, funktioniert dies möglicherweise auch mit früheren Versionen.

Ich habe mein Bestes getan, um meinen Code im selben Stil zu schreiben, den der V5-Quellcode verwendet. (Nicht, dass das schrecklich konsequent wäre.)

Schauen Sie sich hier für Links zu Unix V5, einem Emulator, und Anweisungen zu bekommen es auf einem modernen Computer ausgeführt wird .

Aufgabe 1

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

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

Aufgabe 3

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

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

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

2009 - Idris

Idris ist eine typabhängige, reine Funktionssprache, die neben den äußerst strengen Beweismöglichkeiten, die mit abhängigen Typen erreichbar sind, die praktische Verwendbarkeit für reale Anwendungen hervorhebt.

Aufgabe 1

module Main

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

Aufgabe 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

Dies ist kein Programm, sondern nur eine Funktion (genauer gesagt ein abhängiger Wert ), die den gewünschten Buchstaben N als zweidimensionales Array erzeugt.

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

Aufgabe 3

module gcd

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

Beachten Sie, dass ich den Namen wählen musste, gcd'da gcder bereits im Idris-Vorspiel definiert ist.

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

2014 - Pyth

Da wir CJam haben, könnten wir der Vollständigkeit halber auch Pyth haben :)

Pyth ist eine Golfsprache von @isaacg , die bis zu Python kompiliert wird. Es ist bemerkenswert, dass es prozedural ist und Präfixnotation verwendet. Pyth erschien erstmals im Juni 2014 .

"Hallo Welt!" Variante

"Pyth was made in 2014!

Beachten Sie das Fehlen eines schließenden Anführungszeichens, das optional ist, wenn ein Pyth-Programm in einer Zeichenfolge endet.

ASCII Art N

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

Probieren Sie es online aus . Das äquivalente Python ist:

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

Oder erweitert (die erste und dritte Zeile sind implizit):

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

Dieses Programm verwendet den euklidischen Algorithmus und verwendet zwei durch eine neue Zeile getrennte Zahlen. Probieren Sie es online aus .

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

i.uQist noch kürzer, wenn wir das eingebaute für GCD verwenden. Dies entspricht print(gcd(*eval(input())))(Eingabe von zwei durch Kommas getrennten Zahlen).

1964 - Dartmouth BASIC

BASIC ist eine Familie allgemeiner, übergeordneter Programmiersprachen, deren Designphilosophie die Benutzerfreundlichkeit betont. 1964 entwarfen John G. Kemeny und Thomas E. Kurtz die ursprüngliche BASIC-Sprache am Dartmouth College in New Hampshire. Sie wollten Studenten in anderen Bereichen als Naturwissenschaften und Mathematik die Verwendung von Computern ermöglichen.

Ich schaue mir dieses BASIC- Handbuch von 1964 an und diesen Emulator des Darthmouth Time Sharing Systems, auf dem es lief. Der Server ist immer noch aktiv, aber leider scheint es unmöglich zu sein, ein Konto zu registrieren. Im Moment sollten diese Programme theoretisch funktionieren:

Aufgabe 1

10 PRINT "BASIC WAS MADE IN 1964"
20 END

Aufgabe 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

So etwas ausgeben:

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

Beachten Sie, wie die Eingabe als Teil des Programms ( 70 DATA 5) eingegeben wird . Der READAnweisungsweg oben holt Daten von dort. Es gibt keine Verkettung von Zeichenfolgen. In Abschnitt 3.1 des Handbuchs wird jedoch beschrieben, wie PRINTErgebnisse in tabellarische "Zonen" in der Ausgabe geschrieben werden.

Aufgabe 3

Die langsame Version von Euclids Algorithmus:

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

Ausgabe:

2

2010 - WTFZOMFG

WTFZOMFG ist eine esoterische Sprache, die auf Brainfuck basiert. Es wurde von Jay Songdahl im Jahr 2010 gemacht. "WTFZOMFG" ist die Abkürzung für "What's That Function? Zen Optimized Malicious File Gophers!" .

Hier ist ein Compiler für * nix-Systeme .

Aufgabe 1

'WTFZOMFG was made in 2010!\n"

Aufgabe 2

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

Erläuterung:

Es tut uns leid. Ich kann keine Erklärungen schreiben.

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

Aufgabe 3

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

Euklidischer Algorithmus. WTFZOMFG hat keinen Befehl für mod, daher muss ich d(dividieren), m(multiplizieren) und s(subtrahieren) verwenden.

2009 - Auf geht's

Go ist eine von Google entwickelte Programmiersprache. Die Entwicklung begann 2007, Go wurde jedoch im November 2009 angekündigt.

Go ist eine statisch typisierte Sprache, die von C beeinflusst wird und deren Schwerpunkt auf Prägnanz, Einfachheit und Sicherheit liegt.

Aufgabe 1:

package main
import "fmt"

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

Die erste Zeile deklariert das Paket des Codes. Selbst ein einfaches Beispiel wie das Drucken einer Zeile muss Teil eines Pakets sein. Und die ausführbare Datei wird immer aufgerufenmain .

Schritt 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 hat eine recht präzise Variablendeklaration ( i := 0ist dasselbe wie var i int = 0), und der Compiler bestimmt den Typ. Dies ist in der Regel in dynamischen Sprachen häufiger der Fall. Mit dieser Kurznotation ist es auch sehr einfach, Variablen Funktionen zuzuweisen (f := func(x int) int {/* Code */} ) und Abschlüsse zu erstellen.

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

Hier sehen Sie die a, b = b, a%bSyntax, die wirklich nett ist. Ich kenne den genauen Namen nicht, aber in Python heißt es Tupel auspacken. Auf die gleiche Weise können Sie mehrere Werte von einer Funktion zurückgeben (func f() (int, string) { return 42, "Hallo"} ) zurückgeben.

Eine andere Sache, die in diesem Code passiert, ist die Schleife. Die for-Schleife ist die einzige Schleife in Go. Es gibt keine While-Schleifen oder Do-While-Schleifen. Sie können jedoch problemlos ein Äquivalent für die while-Schleife for condition {}oder eine Endlosschleife erstellen for {}.

1991 - Python

Sprachgeschichte

In den späten 1980er Jahren begann Guido van Rossum, Python als Hobby zu erfinden. Der Name stammt von Monty Pythons Flying Circus, einer britischen Fernsehshow, deren Fan Rossum ist. Die erste Python-Implementierung begann 1989 und wurde 1991 veröffentlicht. Sie hat im Laufe der Jahre an Popularität zugenommen und ist die Sprache der Wahl für viele einführende Informatikkurse geworden.

"Hallo Welt!" Variante

print("Python was made in 1991!")

Beachten Sie die Klammern um die Eingabe bis print . Obwohl diese Syntax in Python 2 funktioniert, lassen Sie diese Klammern normalerweise in Python 2 weg. Sie sind jedoch in Python 3 erforderlich. Wie von Zach Gates vorgeschlagen, werden durchgehend Klammern verwendet, um sicherzustellen, dass der hier vorgestellte Code versionsübergreifend funktioniert.

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

Funktionen werden mit definiert def. Die Verkettung von +Zeichenfolgen erfolgt mit und die Wiederholung von Zeichenfolgen mit* .

GCD

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

Beachten Sie, dass für Python strukturierte Leerzeichen erforderlich sind.

1968 - Algol 68

Algol 68 wurde von der IFIP-Arbeitsgruppe 2.1 als Nachfolger von Algol 60 definiert.

Es ist eine ausdrucksorientierte Sprache, in der alles einen Wert hat. Es ist auch orthogonal, in dem Sie ein beliebiges Konstrukt in beliebiger Weise verwenden können. Dies bedeutet, dass sich Ausdrücke beispielsweise auf der linken und rechten Seite einer Zuweisung befinden können.

Alle Kontrollstrukturen haben eine Kurzform sowie eine Langform mit Ausdrücken. Es erlaubt auch die Definition von Operatoren.

Die Ziele der Sprache werden angeführt als:

Die Hauptziele und Prinzipien des Designs von ALGOL 68:

• Vollständigkeit und Klarheit der Beschreibung
• Orthogonales Design,
• Sicherheit,
• Effizienz
• Statische Modusprüfung
• Modusunabhängiges Parsen
• Unabhängige Zusammenstellung
• Loop-Optimierung
• Darstellungen - in minimalen und größeren Zeichensätzen

Diese Programme wurden mit dem Algol 68 Genie-Interpreter getestet , der eine vollständige Implementierung der Sprache darstellt.

Einige Merkmale, die moderne Programmierer möglicherweise anders finden, sind, dass leere Anweisungen nicht zulässig sind. Sie können nicht einfach ;überall hinzufügen . Sie müssen die SKIPAnweisung verwenden, wenn Sie explizit nichts haben möchten. Es erlaubte auch das Codieren von gleichzeitigen Programmen sehr einfach. Algol 68 verwendete auch, insbesondere, Rückwärtsschlüsselwörter als Terminatoren wie esac , od , fi usw.

Die Sprache hatte eine Darstellung, die zum Schreiben des Codes verwendet wurde, der viele Schriftarten verwendete, die beispielsweise Schlüsselwörter in Fettdruck und Bezeichner in Kursivschrift darstellten . Zu der Zeit, und wahrscheinlich immer noch, hat kein Compiler dieses Feature des Designs implementiert. Die Sprache erlaubte verschiedene konkrete Darstellungen von Programmen unter Verwendung von Stropping-Modi . Dies ermöglichte die Erstellung von Programmen mit begrenzten Zeichensätzen, wie sie in den 1960er Jahren auf Computern vorkamen. Betrachten Sie das kurze Programmfragment, das wie folgt dargestellt wird:

Wenn i < 0, dann überspringe fi

Dies könnte für einen Compiler im Prime- Stropping-Modus vorbereitet werden als:

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

In Punkt Abledern Modus wäre dies:

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

Im Falle eines Abbruchmodus wäre dies:

IF i < 0 THEN SKIP FI

Ich habe eine große Vorliebe für diese Sprache, da ich an einer der Compiler-Implementierungen gearbeitet habe und viele Jahre ausschließlich darin programmiert habe.

Aufgabe 1

print (("Algol 68 wurde 1968 hergestellt!", newline ))

Der hier zu beachtende Punkt sind die doppelten Klammern. Dies liegt daran, dass print eine Funktion ist, die ein einzelnes Argument akzeptiert, das ein Array variabler Länge der Union aller Typen ist. Die innere Klammer ist der Array-Konstruktor. So wird Polymorphismus in dieser stark typisierten Sprache gehandhabt.

Im Fallstropping-Modus:

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


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

Aufgabe 2

     int n ;
     lies (( n ));
     für i von 1 bis n do
          für j von 1 bis n do
               ¢ hier verwenden wir eine abgekürzte IF-Klausel ¢
               print ((( j = 1 OR j = i OR j = n |
                    "N"
               |
                    ""
               ))
          od ;
     print (( newline))
     od

Im Fallstropping-Modus:

 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

Aufgabe 3

     ¢ wir können unsere eigenen Operatoren in Algol definieren 68 ¢
     op % = ( int a , b ) int :
          (( b = 0 |
               a
          |
               b % ( a mod b )
          ));
     int i , j ;
     lies (( i , j ));
     print (( i % j , newline ))

Im Fallstropping-Modus:

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

Die "strengenorientierte und symboLische Sprache". Anfangs offenbar als "Symbolic Expression Interpreter" "SEXI" bezeichnet, das dann geändert werden musste, um zu verhindern, dass die Nerds der 1960er-Jahre rot werden, wenn sie ihre Jobs einreichen. Wahre Geschichte.

Dies war eine der ersten Sprachen, die von Haus aus mit Zeichenfolgen und Mustern umgehen konnte. In der ersten Version von SNOBOL war der String der einzige Datentyp. Mathe wurde dann durch Parsen durchgeführt. Die anfängliche Implementierung erfolgte auf der IBM 7090. Es scheint lange her zu sein, zumindest konnte ich es nicht finden. Was ich gefunden habe, war das Originalpapier, das es beschreibt, sowie ein SNOBOL3-Interpreter in Java, der auf einem modernen Computer ausgeführt werden kann .

Das erste SNOBOL hatte so ziemlich nur Pattern Matching und Grundrechenarten. SNOBOL 3 hat dann Funktionen hinzugefügt und die E / A geändert, scheint aber ansonsten abwärtskompatibel geblieben zu sein. SNOBOL 4 änderte die Syntax und entwickelte sich von dort zu Icon , das die Musterübereinstimmung beibehält, aber ansonsten fast wie eine "normale" Programmiersprache aussieht.

Die Programme, die ich geschrieben habe, verwenden nur die im Originaldokument beschriebenen Funktionen. Sie sollten daher mit dem Original-SNOBOL funktionieren, mit Ausnahme der E / A, die ich im SNOBOL3-Stil ausgeführt habe, damit der Java-Interpreter sie ausführen kann. Aus dem Papier geht hervor, dass der Unterschied darin besteht, dass SNOBOL1 den Mustervergleich mit einer speziellen SYSVariablen verwendet, während SNOBOL3 Eingabe- und Ausgabevariablen verwendet:

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

Wenn Sie diese Ersetzungen vornehmen, erhalten Sie "echtes" SNOBOL 1. Dann können Sie es natürlich nicht ausführen.

Aufgabe 1

START   SYSPOT = 'SNOBOL WAS MADE IN 1962!'

Aufgabe 2

Dies zeigt Mathematik, String-Handling und Flusskontrolle. SNOBOL3 hat nützliche Funktionen, EQum die Gleichheit zu überprüfen. Das Original-SNOBOL tat es nicht, also habe ich sie nicht benutzt.

* 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     

Aufgabe 3

Erstens die langweilige. Das Einzige, was zu bemerken ist, ist der Kleiner-als-Check, der genau zeigt, wie stringorientiert SNOBOL wirklich war: (B - A) '-'bedeutet "Enthält das Ergebnis von BA ein Minus?". SNOBOL3 kann das auch LE(B,A), SNOBOL 1 nicht (zumindest wird es in der Zeitung nicht erwähnt).

* 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

Natürlich wäre es eine Schande, wenn Sie eine Sprache haben, die sich ausschließlich auf Zeichenfolgen und Musterabgleich stützt, wenn Sie den Musterabgleich und das Ersetzen nicht verwenden würden. Hier ist also eine dieser unary-basierten GCDs, einschließlich Routinen zum Konvertieren von und nach unary.

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

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


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

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

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

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

FIN     START

2012 - TypeScript

TypeScript ist eine kostenlose Open Source-Programmiersprache, die von Microsoft entwickelt und verwaltet wird.

Hauptziel ist: Jeder Browser. Beliebiger Host. Beliebiges Betriebssystem. Open Source. Es wurde im Oktober 2012 veröffentlicht

Hallo TypeScript

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

ASCII Art

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

Probieren Sie es online aus und senden Sie es per Screencast .

2011 - Dart

Dart ist eine von Google entwickelte Open Source-Programmiersprache, die als Ersatz für Javascript entwickelt wurde (obwohl sie mit Javascript kompatibel ist). Es wurde von Google im Jahr 2011 während der GOTO-Konferenz vorgestellt.

"Hallo Welt!" Variante:

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

ASCII Art N:

Die Bruteforce-Methode wird mit 0 (n²) ausgeführt, aber es sollte eigentlich keine Rolle spielen, wenn Sie keine riesige Zahl verwenden.

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

einfache Euclid-Methode portiert aus dem Snap! Beispiel oben.

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

2010 - Rust

Rust ist eine universell einsetzbare, multiparadigmatische, kompilierte Programmiersprache, die von Mozilla Research entwickelt wurde. Es soll eine "sichere, gleichzeitige, praktische Sprache" sein, die rein funktionale, gleichzeitig handelnde, imperativ-prozedurale und objektorientierte Stile unterstützt. Wikipedia

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

Erläuterung:

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

sorgt dafür, dass nur vertikal (links und rechts |) und diagonal ( \) gedruckt wird

Aufgabe 3

einfache Implementierung von Euclidean_algorithm

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

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

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

2015 - Muffin MC

Muffin MC ist eine Turing-vollständige, witzige (aber seriöse), funktionale und minimalistische Makrosprache, die von Franck Porcher ( http://franckys.com ) Mitte Februar 2015 aus der Not heraus als (schnelles) Werkzeug zur Stärkung von a geschrieben wurde Kalkulationstabelle als einziges Controller-Frontend verwendet werden , um alle bestandsbezogenen Vorgänge mit Prestashop-basierter Händler - Website zugeordnet ist, um zu Pilot und Antrieb für eine neue Tahitian Modemarke: Mutiny Tahiti ( http://mutinytahiti.com - bald sein gestartet).

Muffin MC ist ein Akronym für MU winzige F unctional F lexible IN Linie M Acro C ommand Sprache.

Um unseren Anforderungen gerecht zu werden, wurden die Kernfunktionen von Muffin MC auf der Grundlage flexibler und effizienter, erstklassiger semantischer Konstrukte wie Iteratoren , Lazy-Evaluation , Multi-Funktoren und String-Produkt entwickelt .

Muffin MC hat seine Wurzeln in der (pragmatischen) funktionalen Programmierung von FLisp und Perl. Es unterstützt vollständig die Rekursivität (ohne Optimierung), ist dynamisch typisiert und verfügt über einen dynamischen Gültigkeitsbereich (flache Bindung). Es bietet seinen Benutzern nur eine Datenstruktur, abgesehen von den grundlegenden Datentypen Atome (Atome, Strings, Ziffern): Listen!

Muffin MC- Listensemantik (Art) leiht sich auf Power-Set- Semantik, das heißt:

1. Alle Muffin MC- Operationen ergeben eine Liste, möglicherweise leer.
2. Der Zugriff auf ein einzelnes Listenelement ergibt immer eine Ein-Wert-Liste, die aus diesem Element besteht (stellen Sie es sich als Singleton vor).
3. Die leere Liste ist das neutrale Element bei Listenoperationen.

Um sich damit abzustimmen, kann Folgendes helfen:

• Man kann sich eine Liste als das Element der Potenzmenge der Liste vorstellen, das die größte Kardinalität aufweist.
• Visualisieren Sie das Element einer Liste als das Element der Potenzmenge der Liste, das der aus diesem Element bestehende Singleton ist.
• Stellen Sie sich eine leere Liste als leere Menge vor. das ist das einzige Element des Potenzsatzes der leeren Menge.

Wenn Sie also auf ein leeres Listenelement zugreifen, erhalten Sie die leere Liste und keinen Fehler! In der Tat versucht Muffin MC , so wenig Fehler wie möglich zu verursachen, indem die Semantik vieler traditioneller Operationen auf diese Weise erweitert wird.

Aufgabe 1

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

#(...)ist der Muffin MC -Makrobefehl zum Anwenden einer Funktion auf eine nicht ausgewertete Argumentliste, hier die sayvon Perl ausgeliehene integrierte Funktion .

#(say 1 2 3 ...) ist funktional identisch mit map {say $_} (1,2,3,...)

Aufgabe 2

Definieren Sie die Funktion 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()kürzeste Arbeitsform (88 Bytes):

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

• =(var val...)ist der Muffin MC- Makrobefehl, mit dem eine Variable definiert oder neu zugewiesen werden kann.

• $(var)ist der Muffin MC- Makrobefehl für den Zugriff auf den Wert einer Variablen. Es akzeptiert natürlich die Form $(v1 v2 ...), auf viele Variablen gleichzeitig zuzugreifen.

• =(* var1 val1 var2 val2 ...)ist die Erweiterung des Muffin MC- Makrobefehls =(...)für parallele Zuweisungen.

• Variablen _1, _2, ... werden dynamisch in den Gültigkeitsbereich eingeteilt (flacher Bindungsmechanismus) und automatisch so festgelegt, dass sie an die Argumente der Funktion binden. Aus Perl5 entliehene Systemvariablen #(Anzahl der Argumente) und @(Liste der Argumente) werden ebenfalls automatisch festgelegt.

• Funktionen sind einfach Variablen, die an eine beliebige Anzahl von Muffin MC- Anweisungen gebunden sind .

Diese interessante Lösung ergibt sich aus der Kombination von zwei integrierten Funktionen des natürlichen Muffin MC :

1. Der Muffin MC- I(...) Makrobefehl zum Definieren von Cycling-Iteratoren, der später mit der Funktionsform verwendet #(my-iterator want-number-of-values)wird.

2. Das Muffin MC- String-Produkt- Konstrukt, eine Erweiterung der natürlichen variablen Interpolation, die bei jedem String "F1 F2 F3...", bei dem die F i entweder Muffin MC- String-Literale oder Muffin MC- Makrobefehle (auch als funktionale Formen bezeichnet) sind, so viele Strings wie möglich erzeugt gegeben durch das Produkt Kardinal (F1) x Kardinal (F2) x ....

Wenn zum Beispiel xa eine Variable mit 2 Werten ist, sagt a und b, und y eine andere Variable mit 3 Werten, sagt 1 2 3, dann ergibt die Auswertung des Strings "x=$(x) y=$(y))"6 verschiedene Werte, und zwar in dieser Reihenfolge:

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

Dies ist eine der begehrenswertesten Funktionen des MUTINY-Projekts, für die Muffin MC entwickelt wurde.

Starte es !

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

Wie funktioniert es

Unser Algorithmus basiert auf Folgendem:

Bei Aufruf von ascii-art (n) ist {n = 2p + 1 | p integer, p> = 0}, die zu erzeugende Kunst besteht aus n Zeichenfolgen mit n Zeichen, von denen zwei, die am weitesten links und rechts liegen, fest und immer gleich sind: 'N'. Dies ermöglicht es, das Problem bei der Herstellung nur der mittleren Saiten zu verringern. Zum Beispiel würden wir bei n = 5 die folgenden 5 mittleren Zeichenfolgen aus jeweils n-2 Zeichen erzeugen (wir haben das Leerzeichen zur besseren Visualisierung durch ein '_' ersetzt):

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

• Solche mittleren Saiten können leicht hergestellt werden, indem die Sequenz mit 4 Elementen ('_' '_' '_' 'N')in 5 Gruppen von 3 durchlaufen wird; Bei n, der Eingabe der Funktion, besteht diese Sequenz aus n - 2 Zeichen '_', gefolgt von dem Zeichen 'N'. Das Durchlaufen dieser Sequenz erfordert nichts anderes als das Einbetten der Sequenz in einen in Muffin MC I(sequence) integrierten Iterator (ein Iterator, der für immer durch die ursprüngliche Folge von Werten läuft).

• Wir erzeugen dann einfach die mittleren Zeichenfolgen mit der Länge n-2, indem wir unseren Iterator bitten, uns die nächsten n-2-Werte (n - 2 Zeichen) mitzuteilen, die miteinander verkettet werden, um die erwartete mittlere Zeichenfolge zu erzeugen.

• Die n mittleren Zeichenfolgen werden durch n-maliges Wiederholen des obigen Vorgangs unter Verwendung einer Karte erzeugt, um die n Ergebnisse (n Zeichenfolgen mit n-2 Zeichen) zu sammeln.

• Wir verwenden eine andere leistungsstarke Muffin MC Einbau-Konstrukt, nämlich die Zeichenfolge Produkt , die n final Strings zu erzeugen: "N#(map...)N".

• Und das ist es !

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

Aufgabe 3

Definieren Sie die Funktion gcd():

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

gcd()‚s reale kürzeste Form (37 Bytes - 2bytes gewinnen dank Rodolvertice)

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

Starte es !

#(gcd 225 81)

ergibt 9.

Das ist es.

Vielen Dank für das schöne Spiel und möglicherweise für Ihr Interesse. Die Sprache steht jedem zur Verfügung, der damit spielen, sie verwenden oder sogar erweitern möchte. Fragen Sie einfach danach und ich schicke es Ihnen gerne zu.

Prost

Franck

PS. Die aktuelle Implementierung von Muffin MC ist Perl5. Der Quellcode besteht aus ca. 2000 Zeilen modernen Perl-Codes, einschließlich Kommentaren, und wird mit einer regressionsfreien Testsuite geliefert, die sich hervorragend zum Erlernen von praktischen Muffin- MC- Konstrukten und -Semantiken eignet .