年間を通じてプログラミング言語


168

この課題では、ユーザーは、プログラミング言語で3つのかなり単純なコーディングタスクを順番に完了します。

最初の回答では、2015年に作成されたプログラミング言語を使用する必要があります。2015年の言語から少なくとも1つの回答があれば、2014年に作成されたプログラミング言語を使用できます。少なくとも1つの2014年の回答があるまで。

一般に、Y + 1年の言語を使用した回答が提出されるまで、Y年のプログラミング言語の使用は許可されません。唯一の例外はY = 2015です。

あなたの言語の年を見つける

この質問に答えるには、プログラミング言語が「作られた」年を知る必要があります。もちろん、これは主観的な用語です。一部の言語は複数年にわたって開発され、多くの言語が毎年アップグレードされています。言語が「作られた」年を、その言語の実装が一般に公開された最初の年としましょう。

たとえば、Python1991年に「作成」されましたが、その開発は1989年から進行中で、バージョン1.0は1994年までリリースされていませんでした。

今年がまだ主観的な場合は、常識を使用して最も適切な年を選択してください。年の選択についてわずかな意見の相違で動揺しないでください。言語がいつ作成されたかを示すソースへのリンクを提供してください。

プログラミング言語の異なるバージョンまたは標準(Python 1、2、3など)は、同じ初年度の同じ言語としてカウントされます。

したがって、言語の年が2015年でない限り、言語の年があなたの直前の年である回答が送信された後にのみ、回答を送信できます。

あなたと同じ年の有効な回答が既に存在する場合は、回答できます。あなたの言語がその年の早い時期に開発されたか、遅い時期に開発されたかは関係ありません。

タスク

タスク1〜3を完了する必要があります。タスク0はオプションです。

これらのタスクは、出力の提供(タスク1)、ループ(タスク2)、および再帰(タスク3)の3つの重要な側面に対応するために選択されました。

タスク0-言語履歴(オプション)

選択したプログラミング言語の歴史を説明する段落を少なくとも1つ書いてください:誰がそれを開発したのか、なぜ、どのように、など。言語があなたやあなたの仕事、またはそのようなものに与えた影響についての個人的な逸話をお気軽に伝えてください。

あなたが若すぎて多くの研究をせずにあなたの言語の歴史について多くを知ることができない場合、あなたの投稿を編集し、いくつかの直接の履歴を追加できると言うメモを高齢ユーザーに残すことを検討してください。

タスク1-「こんにちは、世界!」バリアント

印刷するプログラムを書く

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

ご使用の言語の標準出力領域(最新の言語の場合は標準出力)。

たとえば、言語がPythonの場合、出力は次のようになります。

Python was made in 1991!

タスク2-アスキーアートN

ユーザーが奇数の正の整数を入力できるプログラムを作成し(入力は常に有効であると想定できます)、文字を使用して作成されたASCIIアート文字Nを出力しNます。

入力が1の場合、出力は次のとおりです。

N

入力が3の場合、出力は次のとおりです。

N N
NNN
N N

入力が5の場合、出力は次のとおりです。

N   N
NN  N
N N N
N  NN
N   N

入力が7の場合、出力は次のとおりです。

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

パターンはこのように続きます。出力には末尾スペースが含まれる場合があります。

タスク3- GCD

ユーザーが2つの正の整数を入力できるプログラムを作成し(入力は常に有効であると想定することができます)、最大公約数を出力します。これは、残りを残さずに両方の数値を除算する最大の正の整数として定義されます。ユークリッドアルゴリズムを使用して容易に計算できます。

例:

8124
1284
3303
568921
2348766

組み込み関数を使用できますが、言語の最初のバージョンにあるかどうかを確認してください。そうでない場合は、使用しないでください。

ルール

  • 複数回回答することもできますが、新しい回答では、最後の回答の言語より少なくとも5年前に作成された言語を使用する必要があります。したがって、2015年の言語で回答した場合、2010年の言語が許可されるまで再び回答できませんでした。2010年の回答から開始する場合、2015年は2010年以前ではないため、2015年の回答を2番目の回答にすることはできません。
  • 可能であれば、言語の最初のバージョン(または可能な限り古いバージョン)で機能するようにコードを記述してください。(一部の言語の古いコンパイラー/インタープリターを見つけるのは難しいため、これは要件ではありません。)
  • 投稿された回答に重大なエラーがないか、タスクを完了する方法がまったく異なる場合を除き、既に投稿されている言語を投稿しないでください。
  • コードをゴルフしても問題ありませんが、必須ではありません。
  • プログラムの出力の末尾の改行は問題ありません。
  • タスク2および3の場合、2 16のような合理的な最大値以下のすべての入力値が機能するはずです(少なくとも256)。
  • この質問が投稿される前に、あなたの言語が存在していなければなりません。
  • 非常に古いプログラミング言語は、現在考えているものとは異なる形式の入力と出力を持っている場合があります。これは大丈夫です。あなたの言語の文脈であなたの能力の最大限までタスクを完了してください。

得点

提出のスコアは次のとおりです。

upvotes - downvotes + (2015 - languageYear) / 2 

したがって、2015年以前の毎年の投票数には0.5が加算され、古い言語に有利になります。最高スコアの提出が勝ちです。

回答リスト

以下のスタックスニペットには、言語年ごとに有効な回答がすべてリストされています。

正しくリストされていることを確認するには、このMarkdown行で投稿を開始する必要があります。

#[year] - [language name]

例えば:

#1991 - Python

言語名はリンクに含まれている場合があります(回答リストでは同じリンクになります)。

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

この形式に従わない回答、まだ許可されていない年、または過去5年間に既に回答したユーザーからの回答は無効としてマークされます。

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


2
これは役立つはずです。
-swish

20
ウィキペディアにはすべてのリストがあります。これは非難解な言語の年ごとのリストです。
-Sanchises

2
タスク3は実際に再帰を使用するべきですか、それとも正しい結果を生成するのに十分ですか?独自のGCD関数を作成する必要がある場合、通常はループを使用しますが、この課題のために特別に再帰的なループを作成しました。ループを使用するだけの多くの回答があります。
CJデニス

5
私はちょうど1971年を過ぎて私たちを取得するために、第2のアカウントを作るように感じる
マリナス

5
1952年に戻すことができれば、1951年(ペガサス)のソリューションを実行してテストできる歴史的なマシンを回転させる人がいます!
ブライアントムプセット-汤莱恩

回答:


173

2013-Dogescript

Dogescriptは、2013年にZach Bruggemanによって作成された言語です。Javascriptを、ミームShiba Inusの内部モノローグのように読むようにすることは、Javascriptの構文置換にすぎません。

ハロードージェ

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

アスキーアート

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

113
うわー、そのような+1。非常に答えます。多くの品質。
アレックスA

27
この答えに賛成するためだけにcodegolfに参加しました!
デレクトームス

21
私も真顔でGCD 1を読み取ることができない
コール・ジョンソン

16
gcd_dogeをgood_dogとして読み取ることができません。ヘルプ
ヤン

素晴らしい。ただし、LANGUAGE.mdによると、二重引用符はサポートされていません。s[i]ビットの説明も大好きです!
ドクトゥール

66

2015- 網膜

Retinaは正規表現ベースのプログラミング言語で、ホスト言語で正規表現を呼び出す不必要なオーバーヘッドなしに、正規表現のみの回答でPPCGチャレンジで競うことができるように書きました。Retinaはチューリング完全です。それを証明するために、2タグシステムソルバーとルール110を実装しまし。C#で記述されているため、.NETフレーバー(デフォルト)とECMAScriptフレーバー(フラグ経由)の両方をサポートしています。

Retinaは複数のモードで動作できますが、計算に最も関連する(およびチューリング完全な)モードは置換モードです。置換モードでは、Retinaに偶数のソースファイルを与えます。これらはペアにされ、各ペアの最初は正規表現で、2番目は置換です。これらは順番に実行され、入力を段階的に操作します。正規表現の前に構成を付けることもできます(で区切られます`)。最も重要なオプション(Retinaチューリングを完全にする)は+、結果が変化しなくなるまでRetinaに置換を適用させます。次の例では、;中間ステージでの出力を抑制するを使用しています。

次の各サブミッションでは、各行は個別のソースファイルに入ります。(または、新しい-sオプションをすべての行を単一のファイルに入れるます。)空のファイル/行はとして表され<empty>ます。単一のスペースを含むファイル/行はとして表され<space>ます。

説明は非常に長いため、投稿の最後に移動しました。

プログラム

"こんにちは世界!" バリアント

<empty>
Retina was made in 2015!

アスキーアートN

これは、STDINが改行で終了していることを前提としています。

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

GCD

これには、STDINが改行で終了しないことが必要です。

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

説明

"こんにちは世界!" バリアント

これはかなり簡単です。入力(空の文字列)を受け取らず、何にも一致せず、に置き換えRetina was made in 2015!ます。また[\s\S]*、たとえばパターンを置き換えることにより、任意の入力に対して機能させることもできます。それはSTDINを丸lurみし、それをすべて出力に置き換えます。

アスキーアートN

これには非常に多くの段階があります。入力を単項に変換し、NsのN x Nブロックを作成し、2つの三角形を「切り出す」という考え方です。個々の段階を見ていきましょう。;中間出力を単に抑制するだけで+、置換がループで適用されることを覚えておいてください。

;`^
#

シンプル:#入力にa を追加します。これは、単項への変換のマーカーとして使用されます。

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

これにより、1桁が単項に変換されます。すでに変換された数字(\d*)を取得し、10回繰り返します。そして、次の桁を取得し、適切な桁数を追加します。この段階では、実際の数字の値は関係ありません。とき#番号の末尾に達すると、正規表現はもはや一致しない、そして変換が行われます。例として、番号127は次のように処理されます

#127
1#27
111111111122#7
1111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111227777777#

ここで、最後の行には正確に127桁の文字が含まれています。

;`#
<empty>
;`\d
N

それを取り除き、#すべての数字をに変換する2つの単純なステージN。以下では、入力7を例として使用します。だから今、私たちは持っています

NNNNNNN

次の段階

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

それぞれNを文字列全体に置き換え(末尾の改行が含まれていることを忘れないでください)、末尾の改行自体も削除します。したがって、これにより、単一の行が正方形グリッドに変わります。

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN

今、上の三角形。最初に、右下隅のNをスペースに変えることから始めます。

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

先読みにより、正しいが変更されますN。これは与える

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNN N
NNNNNNN
NNNNNNN

そしていま

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

は、Nスペース文字の上または左上隅にあるに一致し、スペースで置換する正規表現です。置換が繰り返されるため、これは基本的にフラッドフィルであり、初期スペースから3番目のオクタントをより多くのスペースに変換します。

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

最後に、下の三角形でも同じことを繰り返しますが、異なる文字を使用するため、既存のスペースが間違った塗りつぶしを引き起こしません。

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

シードを設定します。

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

それから

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

フラッドフィルを行います。

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

そして最後に

S
<space>

それらSをスペースに変換すると、完了です。

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

GCD

単項式のGCDは、実際には正規表現では非常に簡単です。このほとんどは、10進数から単項への変換および単項から10進数への変換で構成されます。これはもっとコンパクトにできますが、これはコードゴルフではないので...

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

これらのステージは基本的に上記と同じです。ただし、両方の入力数値が変換され、結果では1sではなくNsが使用されます(重要ではありません)。入力がの場合、18 24これは以下を生成します

111111111111111111 111111111111111111111111

いま

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

GCD計算全体です。多数の1sをキャプチャし、次に後方参照を使用して、その文字列を繰り返して両方の数値を書き込むことができるようにします(他の何もしない)ことにより、共通の除数を照合します。正規表現エンジンでバックトラックがどのように機能するか(つまり.+欲張り)により、これは常に最大の結果をもたらします。自動的に公約数を。一致は文字列全体をカバーするため、最初のキャプチャグループを書き戻すだけでGCDを取得できます。

最後に、単項から小数への変換...

;`$
#: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

これは、以前の単項展開の逆です。現在の文字列に収まる最大の10の倍数を見つけます。次に、残りに基づいて次の数字を選択し、数字をマーカーで移動しながら10で倍数を除算します。

#|:.*
<empty>

そして最後に、マーカー、区切り文字、およびヘルパーの数字を取り除くためのクリーンアップ手順です。


数値入力を単項文字列に変換する命令と、単項文字列を数値入力に戻す命令を追加する必要があると思います。純粋な正規表現による変換はクールですが、あまりにも不格好です。
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

8
+1 2015年の投稿はCodeGolfが使用する言語になると確信していました。
ゼロファイバー

@ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳私はそれを以前に考えていました。ほとんどのコードゴルフでは、おそらく単項入力を使用すると思います(チャレンジで "10進数"または何かが明示的に指定されていない限り...)。これについても同じことを考えましたが、これはコードゴルフではありません。10進数の入出力も処理できることを示したかったのです。
マーティンエンダー

6
素晴らしい仕事。網膜は本当にクールです。余談ですが、あなたの名前の横にあるダイヤモンドを見るのもとてもクールです!:)
アレックスA.

おもしろいことに、このコンテストでは古い言語が好まれていますが、この最も若い言語がまだ勝っています=)
Claudiu

60

2013-スナップ

スナップスクラッチに基づいた言語ですバークレー大学で作成さに。これは、一流のデータとカスタムブロック(機能)を備えたScratchへのアップグレードです。スクラッチのように、それはテキストベースではなく、視覚的な「ブロック」によって一緒にスナップされます。

スナップJavaScriptで書かれたBYOBの後継であり、Squeak Smalltalkで書かれました。スナップ2013年3月に一般消費者向けにベータリリースされました

スナップ実際には難解な言語ではありません。これは、Beauty and Joy of Computing(BJC)のプログラミング言語として使用されます。、バークレーなどで開催 AP CSコース。

私はテストなどを手伝いました。

「Hello World」バリアント

アスキーアート「N」

enter image description here

これは、一部のブロックにstdlibを使用します。

ここでかなり基本的なループ。入力を受け取ります。次に、すべてを一緒に追加して言います(n = 5の結果):

enter image description here

ここでは、Snap!モノスペースのことを言っていません。

GCD

ユークリッドアルゴリズムはそれほど高速ではありませんが、動作し、非常に単純です。(申し訳ありませんが、ブロック名にタイプミスをしました。保存せずにタブを閉じました。そのままにしておく必要があります。)

enter image description here

この関数定義は、このブロックを生成します:

enter image description here


3
これは、アリスのプログラミングのように
たくさん見え

4
それは、ブロックベースの言語で得られるものです。それに来て、多くの言語が似ています。;)
Scimonster

1
Scratchにもmod関数があるため、if(b == 0)then else GCM(b、a%b)
-Alchymist

55

2007-LOLCODE

言語の歴史

LOLCODEは、2007年にランカスター大学の研究者であるAdam Lindsayによって作成されました。その構文は、Cheezburger、Inc.によって普及したlolcatsミームに基づいています。

"こんにちは世界!" バリアント

HAI
VISIBLE "LOLCODE wuz maed in 2007!"
KTHXBYE

アスキーアートN

HAI

BTW, read n from stdin
GIMMEH n

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

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

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

        VISIBLE "N"

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

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

            VISIBLE "N"
        IM OUTTA YR closet

        VISIBLE "N"!

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

        VISIBLE "N"
OIC

KTHXBYE

値は、stdinから文字列(YARN)として読み取られます GIMMEH。1を掛けることで、数値(NUMBR)に変換できます。

値は次を使用して標準出力に出力されます VISIBLEます。デフォルトでは改行が追加されますが、感嘆符を追加することで改行を抑制することができます。

GCD

HAI

GIMMEH a
a R PRODUKT OF a AN 1

GIMMEH b
b R PRODUKT OF b AN 1

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

VISIBLE SMOOSH "gcd is " a

KTHXBYE

SMOOSH 文字列の連結を実行します。


13
最後に、誰もが理解できる言語。
ASCIIThenANSI

26
IM IN YR toilet UPPIN YR butt素敵な変数名
コールジョンソン

13
@ColeJohnson:私は常に変動状況で意味をなすの名前ではなく、選択しようとするx1x2など
アレックスA.

2
形〔人や映画などが〕とても面白い、人を笑わせる〔パーティーなどが〕大はしゃぎの、愉快に騒ぐ〔人が〕大喜びの、陽気な。私は職場でこれを読むべきではありません。
アランフーバー

@AlanHoover:明らかに、lolzはjobzよりも重要です。
アレックスA.

43

1982- PostScript

PostScriptは、ベクターグラフィックスと印刷を作成するための言語です。

Adobeは1982年に設立され、最初の製品はPostScriptでした。この言語はプリンターで使用されていました。コマンドはプリンターによって解釈され、ラスターイメージが作成されてからページに印刷されます。1990年代にレーザープリンターの非常に一般的なコンポーネントでした。しかし、プリンタ上で明らかにCPUを大量に消費し、コンピュータプロセッサがより強力になるにつれて、プリンタよりもコンピュータ上でラスタライズを行う方が理にかなっています。PostScriptは多くのハイエンドプリンターに存在しますが、コンシューマープリンターではほとんどなくなりました。

PostScriptを置き換えた標準は、PDFと呼ばれるあまり知られていない形式です。

PostScriptは、プログラミングを開始する頃には流行していませんでしたが、TeXのドキュメントを作成する別の方法として、大学にいる間に少し学びました。私が使用していた他のプログラミング言語(逆挿入記法、スタック、コンソールではなくページへの印刷)とはまったく異なっていましたが、この古い言語を少しだけ楽しんでください。

PostScriptは印刷言語であるため、PostScriptを使用して何かを印刷し、出力をコンソールに送信する方が適切と思われます。

タスク1

/Courier findfont
12 scalefont
setfont
newpath

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

最初の数行は、描画するキャンバスを設定します。次に、movetoコマンドはPSに特定の位置に描画するように指示showし、ページに文字列を印刷します。括弧は、引用符ではなくPostScriptの文字列をマークすることに注意してください。

タスク2

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

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

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

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

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

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

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

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

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

  } repeat

  end
} def

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

「ASCIIアート」Nを描画する関数を作成しましたが、PostScript関数が引数を取る方法はありません。代わりに、引数をスタックにプッシュし、それらを元に戻します。それは/x exch defラインです。

例:スタックがであると仮定します8 9 2。最初に名前/xをスタックにプッシュするため、スタックはになり8 9 2 /xます。exch演算子は2つのスタックの値を入れ替え、今スタックがあります8 9 /x 2。次にdef、上位2つのスタック値をポップし/x、値を持つように定義します2。スタックは今8 9です。

PostScriptを使い始めたとき、これは少しわかりにくいと感じました。理論的な概念としてスタックについて読みましたが、実際に使用したのはこれが初めてでした。

関数の残りの部分は描画コードです。右下隅から開始し、一度に左から右、対角線に向かって行を埋めていきます。

タスク3

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

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

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

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

      /x x cvi def
      x

    } ifelse
  } ifelse
} def

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

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

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

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

} def

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

  xcoord ycoord moveto
  result 20 string cvs show

  % end
} def

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

繰り返しになりますが、ユークリッドのアルゴリズムの形式を使用しましたが、PostScriptにはモジュロ演算子が組み込まれていることを忘れていたため、独自に記述する必要がありました。これは、スタックベースのプログラミングの制約を思い出させるのに役立ちました。私の最初の実装はmodulo再帰に基づいていました:

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

x大きくてyも小さくても(5689と2など)実行しようとするまでは問題ありません。スタックには最大250個の要素しか配置できないため、スタックの制限をかなり超えてしまいました。おっと。私はそのボードに戻る必要がありました。

GCDコード自体は非常に単純です。しかし、関数が引数を取ることができないように、戻り値はありません。代わりに、結果をスタックにプッシュして、他の誰かが後でそれをポップできるようにする必要があります。それは何だab a gcd linesが行うことです。評価が終了すると、値をスタックにプッシュします。

すべてのコードをドキュメントに入れて印刷すると、出力は次のようになります。

enter image description here


8
ハハ私は印刷された紙の写真が大好きです。1982
アレックスA.

1
また、(リテラル)スタックオーバーフローをどのように取得したかについての説明に感謝します。今では、言語に最大再帰深度がある理由がより直感的にわかりました。
DLosc

2
@AlexA .:ええ、でもドットマトリックスの印刷(紙の側面に穴がある)はもっと適切だったでしょう。;-)
アモスM.カーペンター

@ AmosM.Carpenter:実際には、ドットマトリックスプリンターがPostScriptをサポートしたことはないと思います。それは常にレーザープリンターにかなり結びついています。
ninjalj

41

2009- > <>

Befungeに触発された> <>(Fish)は、難解なスタックベースの2D言語です。つまり、プログラムフローは上下左右に移動できます。> <>の初期バージョンは、どこ[]作成されたスレッドを終了しますが、簡単にするためには、これらの命令は、それぞれの新しいスタックを作成し、削除に変更した理由があります。

> <>の現在の公式通訳はここにあります。残念ながら、Esolang wikiの古いインタープリターへのリンクは壊れています。

"こんにちは世界!" バリアント

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

文字列が逆方向に書き込まれる方法に注意してください。> <>には技術的に文字列がなく、唯一のデータ型はchar、int、floatの奇妙な組み合わせです。"文字列解析を切り替えて、終了するまで各文字をスタックにプッシュします"

次に、コードの後半でスタックの長さをプッシュし、lゼロかどうかをチェックし、そうで?!あればプログラムを終了します;。それ以外の場合、命令ポインタは続行し、o実行前にスタックの最上部を出力しますbb+0.。これ(22, 0)により、lループが作成されます。

アスキーアートN

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

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

   \                                                         <   /

明確にするために間隔を空けます。こちらの新しいオンラインインタープリターでこれを試してみて、指示ポインターが行き来するのを確認してください。「初期スタック」テキストボックスに数字を入力することを忘れないでください。Pythonインタープリターを介して実行している場合、-vフラグを使用してスタックを初期化します。例えば

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

このプログラムでは、入力nをレジスタに入力し、&0をプッシュします。これをi「反復」と呼びます。プログラムの残りの部分は、次のような巨大なループです。

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

次に、ループを最初から繰り返します。

矢印^>v<はプログラムフローの方向を変更し、ミラー/\はプログラムフローの方向を反映します。

GCD

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

以下は、ゴルフのプログラムがどのように見えるかの例です。もう一度、オンラインインタープリターでこれを試すことができます(「初期スタック」ボックスにコンマで区切られた2つの値を入力します(例111, 87))か-v、Pythonインタープリターのフラグを使用して(例:

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

このプログラムはユークリッドアルゴリズムを使用します。以前に用意したGIFは次のとおりです。

enter image description here

> <>はトロイダルであるため、左下のv命令が実行されると、命令ポインターは下に移動し、折り返されて上部に再び表示されます。


編集:コードを完全に右から左に実行することにより、@ randomraは3バイトを

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

私はそれを十分にゴルフしなかったと思います:)


27
そして、それが私が名前><>が回文であることがわかった方法でした。
ゼフアイゼンバーグ

33

2012- エレメント

これは、2012年初頭にシンプルなゴルフ言語として考案した言語です。これにより、オペレーターのオーバーロードがほとんどないか、まったくないことを意味します。演算子は、ほとんどの現代のゴルフ言語よりも単純で数も少ないです。

この言語の最も興味深い機能は、そのデータ構造です。2つありますスタックとの情報を格納するために使用されているハッシュが。

mスタックは、算術演算およびその他のほとんどの操作が行われるメインスタックです。データが入力または印刷されるとき、これがデータの取得先または取得元です。

c-stackは制御スタックです。これはブール演算が行われる場所です。Cスタックの最上位の値は、条件としてIfおよびWhileループで使用されます。

ハッシュは変数が保存される場所です。;~保存し、それぞれ、ハッシュからデータを取り出します。

要素は非常に弱く型付けされた言語です。Perlの機能を使用して、数値を文字列として自由に解釈し、逆も同様です。

私はそれに取り組んでいますが、言語のすべてのドキュメントを含めることもできます。 Perlで書かれた2012年オリジナルのインタプリタは、ここにあります。更新:より使いやすいバージョンを作成しました。これはここにあります

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

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

タスク1-テキストの印刷

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

この言語の厄介な部分の1つは、文字列の区切り文字がないことです。このため、この文字列にはエスケープ文字が必要です。`末尾の文字列を出力します。

タスク2-アスキーアートN

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

ここでは、いくつかのスタック操作を目撃します。説明をフォーマットしやすくするために、改行をにL、スペースをに置き換えます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

この答えを極端にゴルフした後、39バイトのソリューションを見つけましたが、はるかに複雑です。

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

タスク3-GCD

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

これはスタックベースの方法です。

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

29

2012- ジュリア

言語の歴史

Juliaは2012年にJeff Bezanson、Stefan Karpinski、およびViral Shahによって開発され、Jeffはマサチューセッツ工科大学(MIT)の学生であり、アランエデルマン教授の助言を受けました。彼らは、さまざまなアプリケーションでの使いやすさを維持しながら、オープンソースで、高速で、動的な(他の多くのものの中で)プログラミング言語への欲求に動機付けられました。製品は、高性能の科学計算への新しいアプローチであるジュリアでした。

"こんにちは世界!" バリアント

println("Julia was made in 2012!")

ジュリアのSTDOUTへの印刷は非常に簡単です!

アスキーアートN

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

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

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

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

コードは読みやすくするためにインデントされていますが、Juliaは空白に制限を課していません。

GCD

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

関数にリストされている最後のものが暗黙的に返されます。


27

1988- Mathematica

または、Wolfram言語と呼ぶべきですか?

タスク0

Mathematicaの作成者は、Wolfram Researchの創設者兼CEOであるStephen Wolframです。Mathematicaの開発前は、物理学者でした。物理学では膨大な代数計算が行われたため、彼はMacsymaのユーザーになりました。

Wolframは、20歳の1979年にPHDを取得しました。物理学を行うにはMacsymaよりも優れたCASが必要だと考えたため、SMPを書き始めました。( "Symmbolic Manipulation Program")。SMPの最初のバージョンは1981年にリリースされました。SMPはMathematicaの前身でした。Mathematicaに大きな影響を与えましたが、そのコードはMathematicaで使用されていません。

1986年、Wolframは「究極の計算システム」を書くことにしました。彼は1986年にコードの記述を開始し、1987年にWolfram Researchを設立しました。最後に、Mathematica 1.0は1988年6月23日にリリースされました。

Mathematica 1.0

Mathematica 1.0が見つかりませんでした。実際、Mathematica 1.0にはWindows版もLinux版もありませんでした。しかし、中国のWebサイトでMathematica 2.0を見つけました。Windows XPでも実行できます。

Mathematica 2.0

タスク1

Print["Mathematica was made in 1988!"]

または単に:

"Mathematica was made in 1988!"

タスク2

今日のMathematicaでは、次のように書くことができます。

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

JuliaおよびRと同様に、これは行列解です。Mathematicaでは、パターンマッチングを使用してスパース行列を定義できます。

ただし、SparseArrayMathematica 5.0で導入されたため、Mathematica 1.0では使用できません。

以下はMathematica 1.0で動作するソリューションです:

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

Mathematica 2.0で導入されたf[i_, 1 | i_ | n] = "N"ため、記述できませんAlternatives

タスク3

組み込み関数を使用するだけです:

gcd = GCD

または、GCDの定義を使用できます。

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

または、一般的にLCMはGCDから計算されますが、LCMを使用できます。

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

または、パターンマッチングでユークリッドアルゴリズムを使用できます。

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

または匿名関数として:

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

上記のすべての関数はMathematica 1.0で導入されました。


3
これは私よりもはるかに良い答えです。削除します。
マーティンエンダー

25

1999- XSLT

World Wide Webコンソーシアム(W3C)は、次の例では、入力がで囲まれていると仮定などXMLをHTMLに変換するためのXSLT、テキストを、作成し<input>..</input>たタグ。

タスク1

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

これは簡単です。input最上位のタグに一致し、目的の出力に置き換えます。

タスク2

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

これは、2つの再帰的なテンプレートとloopを定義していますspacesloopパラメータ付きinn、から開始し、から開始するための目的の出力を生成ispacesパラメータでn生成されます。nスペースます。

タスク3

これの入力は<input><num>..</num><num>..</num></input>タグである必要があります。

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

これgcdは、ユークリッドアルゴリズムを使用する単なる再帰的なテンプレートです。


そして、彼らはINTERCALは奇妙だと言います!
kirbyfan64sos

2
@ kirbyfan64sos公平を期すために、とにかくこのようなものに使用すべきではありません...
LegionMammal978

24

2014-CJam

CJamはPPCGユーザーaditsuによって作成され、2014年4月頃にリリースされました。

"こんにちは世界!" バリアント

"CJam was made in 2014!"

CJamは、プログラムの最後にスタックの内容を自動的に印刷します

アスキーアートN

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

コードの説明:

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

Nの高さ/幅をSTDINを介して入力として受け取ります。こちらからオンラインでお試しください

GCD

l~{_@\%}h;

STDINを介して入力として2つの数値を受け取ります。こちらからオンラインでお試しください


これは[code-golf]ではないことを理解していますが、ASCIIアートNプログラムをri_S*0'NtW'Nta1$*\,Sf*'Nf+..e>N*現代のCJamに短縮できます。
エソランジングフルーツ

24

1990- ハスケル

Haskellは人気があります(または言うべきです:最も人気のある?)純粋な関数型言語です。それはその珍しい評価モデルによって主流から突き出ています(デフォルトでは、すべてが怠zyですか、技術的には厳密ではない)と、現在でもまだ最も強力なHindley-Milnerベースの型システム突出しています。

タスク1

main = putStrLn "Haskell was made in 1990!"

タスク2

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

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

デモ、無限リスト全体を印刷(ユーザーが中断するか、世界が終了するまで)

GHCi> mapM_ (putStrLn . unlines) bigNs
N

NN
NN

N N
NNN
N N

N  N
NN N
N NN
N  N

N   N
NN  N
N N N
N  NN
N   N

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

...

もちろん、無限リストの1つの要素のみにアクセスすることで、これらのうちの1つに簡単にアクセスできます。

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

タスク3

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

23

1972- インターカル

そして、あなたはFortranとCobolは奇妙だと思っていました。これは非常識です!

タスク1

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

INTERCALの入力および出力のシステムを説明するつもりはありません。これを読んでくださいをあなたが死なないことを願っています。

タスク2

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

DO (100) NEXT
DO (1) NEXT

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

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

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

(3) DO (4) NEXT
PLEASE GIVE UP

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

(8) DO (5) NEXT

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

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

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

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

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

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

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

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

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

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

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

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

善良な優しさ。これを理解するのに少し時間がかかりました。ラベル番号は混乱しているため、それを反映しています。誰かが尋ねない限り、これを説明しようとはしません。

タスク3

DO WRITE IN .5
DO WRITE IN .6

DO (1) NEXT

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

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

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

これは少しシンプルです。INTERCALの...奇妙さのために、次のように数字を入力する必要があります。

THREE FIVE

たとえば、42と16のGCDを取得するには、次のように入力します。

FOUR TWO
ONE SIX

また、ローマ数字で数字を印刷します...それはあなたにとってINTERCALだからです!


2
19 7 2じゃないですか?(これを書いた後、あなたが少しめまいがするかどうかは理解できます:P)あなたの答えは、この間違いのために無効であると考えられます。
マリヌス

@marinusありがとうございます!一定!
kirbyfan64sos

5
説明してください。(もちろん時間があります。;)
DLosc

1
INTERCALは、私が学んだことのない私のお気に入りの言語です!
CJデニス

1
PLEASE GIVE UP。すでにやった.-。
RedClover

23

1967-APL

1957年、ハーバード大学で、ケンアイバーソンはアレイ操作のための数学表記の開発を開始しました。1960年代に、彼の表記法はIBMでプログラミング言語に発展しました。最初の部分実装は1963年に作成され、高校でも超越機能について生徒に教えるために使用されました。完全で使用可能な実装は、1965年まで待たなければなりませんでした。2年間、IBMによって内部でのみ使用されていました。1967年、IBMはIBM 1130コンピューターで実行されるAPLインタープリターを公開しました。これは1966年に完成しました。1年を選択するのが少し難しいのは理解できますが、1967年になると思います。これは最初の年であるため、完全な実装が一般に公開されました。誰もが本当に同意しない場合、私はそれを変更することができます。

APL \ 360のソースコード は、エミュレーターと同様にオンラインです。これは、これらの例をテストするために使用したものです。それは1967年からのもので、APL \ 1130(前述のIBM 1130の場合)とともに、ほぼ真のオリジナルです。予想どおり、非常に原始的です。これは、任意の演算子は、小文字などの細かな点のためにサポートしていない唯一の組み込み関数と連携し、組み込み関数のセットは非常にまばらな(特に、されているだけ or、とん ではないと兼用しますgcd)。元の完全な説明はここにあり ますが、私が持っていたバージョンはそのドキュメントに関して完全ではなく、とりわけ欠けていることに気付きました。

プログラムをUnicode形式(読みやすいように)と元のエンコード(エミュレータのAPLウィンドウにカットアンドペーストできるように)の両方で提供しました。

信じられないほど、これらのプログラムは、Dyalog、NARS2000、およびGNU APLの最新バージョンでは、変更なしで(エンコードを除く)正しく実行されます。だから私はポータブルAPLを書く方法を見つけたと思います:1967年のふりをしてください!

タスク1:

Unicode:

⎕←'APL WAS MADE IN 1967!'

APL \ 360:

L[Kapl was made in 1967ÝK

タスク2:

Unicode:

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

APL \ 360:

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

タスク3:

これを標準的な再帰的な方法で解決しました。理論的には、Jの回答のように、巧妙で配列指向の何かを行うことができます。ただし、実際には、O(N)メモリ使用量があり、Flower-Power-era時代のハードウェアとソフトウェアをすぐに圧倒します。

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

これはすごい。
アレックスA.

22

1996- オカムル

1996年に誰かがいっぱいになるのを1日以上待っていたので、Rubyを埋めることができました。では、なぜOCamlを学ばないのか、haskellに似ているようです...

こんにちは世界

print_endline "OCaml was made in 1996!";;

ASCII

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

可変文字列!

GCD

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

いいえ==、挿入記号mod、それはかわいいです


すみません、Rubyで埋めました:)
ゼロファイバー

4
この課題に答えるためだけに言語を学習するための+1。:)
アレックスA.

あなたもF#を学んだだけです!(CLRのOCamlといくつかの追加機能です)。
ロバートフレイザー

22

2005- プレリュード

Preludeは非常に楽しい言語であり、そのソースコードは複数の「音声」で構成されており、それらは並行して実行され、で問題を解決するの大好きです。それは姉妹言語フーガの ASCII表現であることを意味します実際には.midiファイルをソースコードとして使用し、Preludeで見つかった命令を音声のメロディの間隔としてエンコードします。

Preludeはかなりミニマルですが、チューリングは完了しています(少なくとも2つのボイスを使用している場合)。私が言ったように、音声(コードの行)は列ごとに同時に実行されます。各音声は独自のスタックで動作し、スタックは無限のゼロに初期化されます。Preludeは次の指示をサポートしています。

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

いくつかの追加のメモ:

  • 声は周期的ですので、 ^、上部のボイスでは下部のボイスからコピーされます(逆も同様です)。
  • 複数の?!同じ列には、上から下に実行されます。
  • あたりとして言語仕様?および!対応する文字コードと文字を読み書き。ただし、Pythonインタープリターにはコードにスイッチがあり、代わりに数字自体を出力します。テストの目的で、文字の代わりに数字も読み取ることができる修正版を実際に使用しいます。しかし、このあたりのコンセンサスは、数値の入力/出力を実際にバイト値として与えることができるため、数値を扱う有効なプログラムを作成するためにこれらの変更は必要ないということです。
  • マッチング()同じ声である必要はありません。条件のために使用される音声は、常に 1 (が表示されます。したがって、の垂直位置)は完全に無関係です。
  • Preludeの同時実行の性質により、a (と同じ列にある命令は、ループに入る前に、ループに入るかどうかに関係なく、一度だけ実行されます。同様に、a )と同じ列の命令は、ループがこの反復後に終了するかどうかに関係なく、各反復の終わりに実行されます。

最初に、コメントなしで3つのプログラムを紹介します。以下に詳細な説明があります。

プログラム

"こんにちは世界!" バリアント

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

Pythonインタープリターを使用している場合は、 NUMERIC_OUTPUT = False

アスキーアートN

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

使いやすさのために、このプログラムは入力を数値として読み取ることでメリットを得ますが、出力は数値であってはなりません。したがって、変更されたPythonインタープリターを使用している場合は、

NUMERIC_INPUT = True
NUMERIC_OUTPUT = False

GCD

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

これは、すべての数値入出力で最適に使用されます。

NUMERIC_INPUT = True
NUMERIC_OUTPUT = True

説明

"こんにちは世界!" バリアント

これはかなり簡単です。3つの音声を使用して、のすべての文字の文字コードを連続して生成していPrelude was made in 2005!ます。計算から始めます8 + 9*8 = 80。これは、次の文字コードですP

 9(1-)
 8 8+

その後、ほとんどの場合、前の文字コードをコピーして、次の文字コードとの差を加算または減算します。コードは次のとおりですが、それぞれ!が印刷される文字に置き換えられ_ます(およびスペースと%数字用):

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

最終55+!版は、それがより良いという理由だけで、末尾の改行を印刷します。

補足として、音声の数はこのタスクではかなり任意ですが、3はすべての音声が互いに直接アクセスできる最大数であるため、かなり便利です。

アスキーアートN

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

5つの声で、これは間違いなくこれまでに書いた中で最も複雑なプログラムの1つです。音声には、おおよそ次の目的があります。

  1. N-1内側のループで使用するために保存する単なるヘルパーボイス。
  2. これは一種の「メイン」ボイスであり、入力を読み取り、重要なスイッチを含み、外側のループ(つまり、行の上のループ)も含みます。
  3. これにより、32スペースを便利に印刷できます。
  4. これには、内側のループ(列上のループ)が含まれます。
  5. これはを保存するの78に便利Nです。

パートごとにコードを見ていきましょう。まず、私は32as -4 + 9*4とas を作成してい78ます6 + 9*8

9(1-)
4-4+

6 8+

今私は、単一の印刷をしていNた入力を読みながら(私たちは常に1を必要とするので)Nと、保存N-1してN-2最初の二つの声で:

      v2-
     ?1-

     v!

次に、に条件付けられた「ループ」がありますN-1。ループの終わりで、2番目の音声は常にに減少し0、最初の反復後にループが終了します。本質的に、これだけif(N > 1){...}です。ループの後、1つの末尾の改行を出力します。要約すると、次のフレームワークがあります。

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

この条件内で、最初のN-2スペースとN最初の行を完了するためのシングルをN-1最初に配置し、将来の使用のために最初の音声にも保存します:

         (1-)v         
          v!  

             v!

これで、コードの本質です。最初に、N-1行を出力する外側のループがあります。行ごとに、最初に改行とを出力しNます。次にN-2、スペースまたはNsを出力して、時間をループします(これについては後で説明します)。そして最後に、別のものを印刷しますN

               1-55+!  

                v1-v!(               )v!
               v#

最後に、楽しい部分は、各行を印刷することです(そして、N右の位置を取得します)。Preludeにはif / elseは実際にはないので、異なるボイスで2つのループを使用して自分で作成する必要があります。この条件は、内側と外側のループ変数を差し引くことで簡単に取得できます。0印刷Nしたい場合は取得し、スペースを印刷したい場合はゼロ以外の値を取得します。

Preludeのif / elseの基本的な考え方は、関連する値の後にループを配置することです。つまり、「if」(またはゼロ以外)コードで、を押してすぐに終了し0ます。別の音声では、ゼロ以外の値を保持し、「if」ループの後に別のループを保持します。「if」ループ中に、「else」が実行されないように、他の音声の上にゼロを置きます。ゼロ以外の値の上にゼロ値をプッシュするか、ゼロが下にある場合にゼロ以外の値を単純に破棄するかについてはある程度の柔軟性がありますが、これは一般的な考え方です。また、関連する音声を引き続き使用する場合は、後でクリーンアップを実行する必要があります。コードは次のようになります。

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

以上です!

GCD

これは、ユークリッドアルゴリズムの「単なる」反復実装です。しかし、Preludeのモジュロは少し面倒です。これは主に、数値が正か負かを簡単に確認できないためです。このコードは、少し前に書いたsignum実装利用しています。すなわち、コードの大部分はわずかに数をオン-10または1。これは、を加算または減算することにより、正または負の数の条件に簡単に変換できます1

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

今回は4つの声があります。最初の音声は、単にb主な終了条件を追跡し、含んでいます(つまり、にbなるとループが終了します0)。2番目の声はa声3と4の計算の助けを含んでいてa % b、前の結果と交換する前にb。最後に、が!印刷さab == 0ます。

最初にsignum部分を見てみましょう。

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

入力番号nは、これらの音声の最初の部分(プログラム全体の2番目の部分)にあります。結果は下の声になります。他の2つのボイスは空(つまりゼロで満たされている)であることが期待されます。の場合n == 0、両方のループがスキップされ、下の音声にはまだが含まれていることに注意してください0

場合はnゼロで、第1の小ループが入力されます。ゼロを押してすぐに終了し、2つのコピーをn中央の音声と1 つの音声を1下の音声に配置します。ここで、基本的な考え方は、コピーの1つnをインクリメントし、コピーのn1つがゼロになるまで他のコピーをデクリメントすることです。その間1、一番下の声は常にその記号を反転させます(これは0、スタック上のその下からそれを減算することによって簡単に行われます)。これは数字の1がゼロに当たる、下の声が正しい符号が含まれています。

モジュロは、結果が負になるまでbから減算することで実装されますa。その場合は、bもう一度追加します。それはこのビットです:

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

下部のif / else構造に注目してください。これは、タスク2で使用したものと似ています。


2
これは本当にPreludeチュートリアルの一部であるはずです。
アレックスA.

21

2007-スクラッチ

スクラッチは、MITが教育目的で作成した言語です。私はこれに5年間関わってきました。それについては後で詳しく説明します。

これらはすべてここで表示できます

私は今急いでいるので、スニペットについては後で説明します。願わくば、それらは一目瞭然です。

タスク1

enter image description here

タスク2

enter image description here

タスク3

enter image description here


まだ後ですか?
dfeuer

21

1972-C

私たちは皆、Cについて知っていますよね?Cは、UnixとともにBell Labsで作成されました。Unixは主にCで書かれています。最近のUnix派生物はすべてCで書かれています。Cの構文は多くのプログラミング言語に影響を与えています。これはおそらく、最も新しいプログラミング言語として広く使用されている最古のプログラミング言語です。

C自体はBの子孫であり、このリストにも含まれることを期待しています。「A」プログラミング言語はありませんでした。BはBCPLのバリアントであり、BCPLはさらにCPLを削除しています。これらの言語はどれも非常に人気がありませんでした。ただし、BCPLは最初の「Hello World」プログラムが作成された言語でした。別の興味深い事実は、Bがコメント/* *///コメントの両方を持っているが、Cが//コメントを削除したことです。それらは後にC99標準でCに再導入されました。

ここでのCプログラムは、1974年からUnix V5 Cコンパイラでテストされました。これは、私が見つけて作業できる最も古いCコンパイラであり、これらのプログラムは最新のCコンパイラではコンパイルできません。(行われた変更の1つは、突然変異演算子+=が記述されていたことです=+。)

#include <... >まだ存在していません。どちらも標準ライブラリの多くをしませんでした。私は自分で書かなければなりませんでしたatoi。許可されているものと許可されていないものを把握するために、V5ソースコードのいくつかを調べました。使用したバージョンはstructs を含む最初のものでしたが、それらを使用しなかったため、V7まで(K&R Cとして)構文が大きく変更されていなかったため、これは以前のバージョンでも機能する可能性があります。

V5ソースコードが使用するスタイルと同じスタイルでコードを記述するために最善を尽くしました。(しかし、それはひどく一貫しているわけではありません。)

見て エミュレーターであるUnix V5へのリンクと、最新のコンピューターで実行するための手順については、こちらご覧

タスク1

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

タスク2

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

    }
    return num;
}

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

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

タスク3

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

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

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

うわー、Cがどれだけ変わったのか気づかなかった...どこからコンパイラを入手したのですか?
kirbyfan64sos

1
コンパイラは、Unix V5に含まれているものです。説明には、ブログの投稿へのリンクがあり、ファイルの入手先と最新のコンピューターでの実行方法を示しています。(ここにあります)。実行したら、を使用してコードを取得できますcat > file.c。(いつものように、Ctrl-Dで終わります)。あなたが交換する場合:また、Cは、あなたが思っているより少ない変化している=*=+してatoi現代的な同等物のための機能*=+=、現代のGCCは、それらがうまくコンパイルされ、彼らはあまりにも、実行します。警告すらほとんどありません。
マリヌ

1
minnie.tuhs.org/cgi-bin/utree.pl?file=V2/cは、私が見つけることができた最も古いCコンパイラです(V2、72年)。
オベロン

20

2009- イドリス

Idrisは、依存型で達成できる非常に厳密な証明の可能性を提供することを除いて、実際に実際のアプリケーションで実際に使用できることを強調する、依存型の純粋関数型言語です。

タスク1

module Main

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

タスク2

module InN

import Data.Fin
import Data.Vect

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

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

これはプログラムではなく、単なる関数(より正確には依存値)であり、目的の文字Nを2次元配列として生成します。

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

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

タスク3

module gcd

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

Idrisプレリュードで既に定義さgcd'gcdているため、名前を選択する必要があることに注意してください。

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

彼らはHaskellを取り、交換:::、に変更した_ようZです。
wchargin

@WChargin Zは、実際にはのコンストラクタです0 : Nat。アンダースコアは、Haskellと同じようにIdrisでも使用されます。
反時計回りの回転を停止

ああ、まあ、そこに行きます!:)
-wchargin

19

2014-ピス

CJamがあるので、完全性のためにPythもあるかもしれません:)

Pythはによってゴルフの言語である@isaacgのPythonまでコンパイルされます。手続き型であり、プレフィックス表記を使用していることは注目に値します。Pythは2014年6月頃に初めて登場しました

"こんにちは世界!" バリアント

"Pyth was made in 2014!

Pythプログラムが文字列で終わる場合は省略可能な引用符がないことに注意してください。

アスキーアートN

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

オンラインでお試しください。同等のPythonは次のとおりです。

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

または展開されます(1行目と3行目は暗黙的です):

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

このプログラムはユークリッドアルゴリズムを使用し、改行で区切られた2つの数値を取ります。オンラインでお試しください

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

i.uQGCDの組み込みを使用する場合はさらに短くなります。これはprint(gcd(*eval(input())))(入力としてコンマで区切られた2つの数字を取る)と同等です。


Drat-Pyth xPを行うつもりだった-theonlygusti
12:52に

@isaacg不思議に思わずにはいられません。また、ここで質問することもできます。
ɐɔıʇǝɥʇuʎs

@ɐɔıʇǝɥʇuʎsPythを作る前にPYGを見たことがありますが、それは1キャラクター-1コンセプトアプローチに影響を与えた可能性があります。しかし、何かがPythに影響を与えた場合、それはおそらくgolfscriptでした。
isaacg

17

1964- ダートマスベーシック

BASICは、設計哲学が使いやすさを重視している汎用高レベルプログラミング言語のファミリです。1964年、ジョンG.ケメニーとトーマスE.カーツは、ニューハンプシャーのダートマス大学でオリジナルのBASIC言語を設計しました。彼らは、科学と数学以外の分野の学生がコンピューターを使用できるようにしたいと考えていました。

私は1964年からのBASICに関するこのマニュアルと、それが実行されたダースマスタイムシェアリングシステムのこのエミュレータを見ています。サーバーはまだ稼働していますが、悲しいことに、アカウントの登録は不可能なようです。今のところ、これらのプログラムは理論的には動作するはずです。

タスク1

10 PRINT "BASIC WAS MADE IN 1964"
20 END

タスク2

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

次のような出力:

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

プログラムの一部として入力がどのように入力されるかに注意してください(70 DATA 5)。READ上部の命令の方法は、そこからデータを取得します。文字列の連結はありませんが、マニュアルのセクション3.1では、PRINT、出力の表形式の「ゾーン」に結果を書き込むが記載されています。

タスク3

ユークリッドのアルゴリズムの遅いバージョン:

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

出力:

2

最後に、誰かがBASICを実行しました。
マリヌ

16

2010- WTFZOMFG

WTFZOMFGはBrainfuckに基づいた難解な言語です。「WTFZOMFG」は、「その機能は何ですか?Zen Optimized Malicious File Gophers!」の略です。。

* nixシステム用コンパイラを次に示します

タスク1

'WTFZOMFG was made in 2010!\n"

タスク2

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

説明:

ごめんなさい。説明を書くのが苦手です。

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

タスク3

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

ユークリッドアルゴリズム。WTFZOMFGにはmodのコマンドがないため、d(divide)、m(multiply)、およびs(subtract)を使用する必要があります。


16

2009-行く

Goは、Googleが開発したプログラミング言語です。開発は2007年に開始されましたが、Goは2009年11月に発表されました。

Goは、Cの影響を受けた静的に型付けされた言語であり、簡潔さ、シンプルさ、および安全性を重視しています。

タスク1:

package main
import "fmt"

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

最初の行は、コードのパッケージを宣言しています。1行を印刷する単純な例でも、1つのパッケージの一部である必要があります。そして、実行可能ファイルは常に呼び出されmainます。

タスク2:

package main

import (
        "fmt"
        "strings"
)

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

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

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

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

Goには非常に簡潔な変数宣言(i := 0と同じvar i int = 0)、コンパイラが型を決定します。これは通常、動的言語でより一般的な機能です。この短い表記法を使用すると、関数を変数に割り当て(f := func(x int) int {/* Code */})、クロージャーを作成するのも非常に簡単です。

タスク3:

package main

import "fmt"

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

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

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

ここで見ることができます a, b = b, a%b構文ます。これは本当に素晴らしいです。正確な名前はわかりませんが、Pythonではtuple unpackingと呼ばれます。同じ方法を使用して、関数から複数の値を返すことができます(func f() (int, string) { return 42, "Hallo"})。

このコードで起こっている別のことはループです。forループはGoの唯一のループです。while-loopsまたはdo-while-loopsは存在しません。ただし、whileループfor condition {}または無限ループに相当するものを簡単に作成できますfor {}


16

1991- Python

言語の歴史

1980年代後半、Guido van RossumはPythonを趣味として考案し始めました。その名前は、ロッサムがファンである英国のテレビ番組、モンティパイソンのフライングサーカスに由来しています。Pythonの最初の実装は1989年に始まり、1991年にリリースされました。長年にわたって人気が急上昇し、多くの入門コンピューターサイエンスコースの選択言語になりました。

"こんにちは世界!" バリアント

print("Python was made in 1991!")

への入力を囲む括弧に注意してくださいprint。この構文はPython 2で機能しますが、通常はPython 2でこれらの括弧を省略します。ただし、これらはPython 3で必要です。ZachGatesが示唆するように、ここで紹介するコードがバージョン間で機能することを保証するために、括弧を全体に使用しています。

アスキーアートN

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

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

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

関数はを使用して定義されdefます。文字列の連結はとを使用+して文字列の繰り返しを実行します*

GCD

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

Pythonは構造化された空白を必要とすることに注意してください。


16

1968- アルゴル68

Algol 68は、IFIP Working Group 2.1により、Algol 60の後継として定義されました。

これは、すべてが価値を持つ表現指向言語です。また、直交であり、任意の構成を任意の方法で使用できます。これは、たとえば、式が割り当てのRHSおよびLHS上にあることを意味します。

すべての制御構造には、式を使用した長い形式だけでなく、短縮形もあります。また、演算子の定義も許可します。

この言語の目標は次のとおりです。

ALGOL 68の設計の主な目的と原則:

  • 説明の完全性と明確性
  • 直交デザイン、
  • セキュリティ、
  • 効率
  • 静的モードのチェック
  • モードに依存しない解析
  • 独立したコンパイル
  • ループ最適化
  • 表現-最小およびより大きな文字セット

これらのプログラムは、言語の完全な実装であるAlgol 68 Genieインタープリターでテストされています。

現代のプログラマーが異なると感じるかもしれないいくつかの機能は、空のステートメントが許可されていないことです。;どこにでも追加することはできません。SKIP明示的に何も持たない場合は、ステートメントを使用する必要があります。また、並行プログラムのコーディングが非常に簡単になりました。また、Algol 68は、特に、esacodfiなどのターミネーターとして後方キーワードを使用しました。

この言語には、太字のキーワードと斜体の識別子を表す多くのフォントを使用するコードを記述するための表現がありましたたとえば。当時、そしておそらくまだ、コンパイラはデザインのこの機能を実装していませんでした。言語はstroppingモードを使用するプログラムのいくつかの異なった具体的な表現を許可しました。これにより、1960年代のコンピューターに見られるような限られた文字セットを使用してプログラムを準備することができました。次のように表される短いプログラムフラグメントについて考えます。

場合 、私は < 0を 、次に スキップ Fiを提供して

これは、最高のコンパイラーのために準備できますストローピングモードの。

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

では、ドット stroppingモードこれは次のようになります。

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

ケース stroppingモードで、これは次のようになります。

IF i < 0 THEN SKIP FI

私はコンパイラー実装の1つと、長年のプログラミングのみに取り組んでいたため、この言語が大好きです。

タスク1

印刷((「1968年にアルゴル68が作成されました!」、改行))

ここで注意すべき点は、二重括弧です。これは、printが、すべての型の共用体の可変長配列である単一の引数を取る関数であるためです。内側の括弧は配列コンストラクターです。これが、この厳密に型指定された言語でポリモーフィズムが処理される方法です。

ストローピングモードの場合:

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


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

タスク2

     int n ;
     読み取り((n));
     以下のために から 1 、nが 行う
          ため 、J から 1 まで のn やる
               ¢を私たちは省略IF句を使用ここ¢
               プリント(((J = 1 OR J = I OR jは = N |
                    "N"
               |
                    ""
               )))
          ODを
     印刷((改行))
     od

ストローピングモードの場合:

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

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

タスク3

     ¢ Algol 68で独自の演算子を定義できます。¢
     op =int abint
          ((b = 0 |
               a
          |
               b a mod b
          ));
     int ij ;
     read((ij));
     印刷((i j改行))

ストローピングモードの場合:

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


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

7
これらはおそらく、私が30年以上かけて書いて実行した最初のAlgol 68プログラムでした。とても感動的で、実際に涙を流しました。「Hello World!」に気付かなかった プログラムはとても感情的かもしれません!
ブライアントムセット-汤莱恩

1
60年代の言語をとても楽しみにしていたので、BCPL、Simula、CORAL66、Fortran 66、PL / 1、SNOBOL4、POP-1、およびその他すべての準備が整いました。 5年間の言語を待つために...少なくとも他の誰かが耕すための豊かな溝があります。
ブライアントムプセット-汤莱恩

Fortran66(パンチカードによる暴力の混乱)、APL(超大国のシンボルの奇妙な混乱)、そして実際には非常に美しいAlgol68の違いを見るのは本当にクールです。今日、あなたはそのようなさまざまなアプローチを見つけるために難解な言語を調べる必要があります...当時、これはかなり主流でしたね?
反時計回りに回るのをやめた

もちろん、改訂報告書は1976年まで発行されていませんでしたか?少なくともそれは、Springerが与える著作権の年です。そして、私が見つけたスキャンは1978
。–リアルト

[1] A. van Wijngaarden(ed。)、Bl Mailloux、1.EL Peck、CBA Koster、アルゴリズム言語ALGOL 68に関するレポート、Numer。数学。14(1969)79-218; キベニエティカ6(1969)および7(1970)でも同様です。[2] A. van Wijngaarden、Bl Mailloux、1.EL Peck、CBA Koster、M:Sintzoff、CBLindsey、LGLT MeertensおよびRG Fisker、アルゴリズム言語ALGOL 68、Acta Informatに関する改訂レポート。5(1975)パート1〜3(ベルリンのシュプリンガーによって発行された再版、およびアムステルダムのマセマチシュセントラムによってMathematical Center Tract 50として発行された); SIGPLAN Notices 12(5)(1977)
ブライアントムセット-汤莱恩

16

1962-スノボル

「StriNg指向およびsymBOlic言語」。最初は明らかに、シンボリック式インタープリター「SEXI」と呼ばれていましたが、1960年代のオタクが仕事を提出するときに顔を赤らめないように変更する必要がありました。実話。

これは、文字列とパターンをネイティブに処理できる最初の言語の1つでした。実際、SNOBOLの最初のバージョンには、唯一のデータ型として文字列がありました。その後、解析によって数学が行われました。最初の実装はIBM 7090で行われました。少なくとも、私はそれを見つけることができませんでした。私が見つけたのは最新のコンピューターで実行できるJavaのSNOBOL3インタープリターだけでなく、それについて説明した元の論文でし

最初のSNOBOLには、パターンマッチングと基本的な算術しかありませんでした。その後、SNOBOL 3は機能を追加し、I / Oを変更しましたが、それ以外は下位互換性を維持しているようです。SNOBOL 4は構文を変更し、そこからIconに発展しました。これはパターンマッチングを維持しますが、それ以外はほとんど「通常の」プログラミング言語のように見えます。

私が書いたプログラムは、元の論文に記載されている機能のみを使用するため、Javaインタープリターが実行できるようにSNOBOL3スタイルで行ったI / Oを除き、元のSNOBOLで動作するはずです。論文から、SNOBOL1は特殊SYS変数とのパターンマッチングを使用するのに対し、SNOBOL3は入力変数と出力変数を使用するという違いがあるようです。

  • 入力:
    • 1 SYS .READ *DATA*
    • 3 DATA = SYSPPT
  • 出力:
    • 1 SYS .PRINT 'A STRING' AND VARIABLES
    • 3 SYSPOT = 'A STRING' AND VARIABLES

これらの置換を行うと、「実際の」SNOBOL 1になります。もちろん、実行することはできません。

タスク1

START   SYSPOT = 'SNOBOL WAS MADE IN 1962!'

タスク2

これは、数学、文字列処理、およびフロー制御を示しています。SNOBOL3には、EQ同等性をチェックするなどの便利な機能があります。オリジナルのSNOBOLは使用しなかったため、使用していません。

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

* INITIALIZE
        CS = ''
        ROW = '0'

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

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

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

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

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

* OUTPUT THE LAST LINE
FIN     SYSPOT = CS     

タスク3

まず、退屈なもの。唯一の注意事項は、小なりチェックであり、文字列指向のSNOBOLが実際にどのようであったかを正確に示します。(B - A) '-'つまり、「BAの結果にマイナスが含まれますか?」という意味です。SNOBOL3もできますがLE(B,A)、SNOBOL 1はできませんでした(少なくとも、論文では言及されていません)。

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

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

もちろん、文字列とパターンマッチングに完全に基づいた言語を使用している場合、パターンマッチングと置換を実際に使用しないのは残念です。したがって、単項への変換と単項からの変換を行うルーチンを含む、単項ベースのGCDの1つを次に示します。

* 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

優れたバックグラウンドワーク!1961年のためのあまりない- COMITは、我々が持っているすべてであるように、それは....に見える
ブライアンTompsett -汤莱恩

15

2012-TypeScript

TypeScriptは、Microsoftが開発および保守している無料のオープンソースプログラミング言語です。

主な目標は次のとおりです。任意のブラウザ。任意のホスト。すべてのOS。オープンソース。にリリースされました2012年10月

こんにちはTypeScript

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

アスキーアート

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

オンラインそれを試して、そしてスクリーンキャストもの。


4
1つのことを忘れていました。TypeScriptはJavascriptのスーパーセットであり、構文の変更はほとんどなく、強い型指定の変数と引数を許可します(?)。
イスマエルミゲル

1
神よ、MSのオープンソースです!
メガマン

15

2011-ダーツ

Dartは、Googleによって開発されたオープンソースのプログラミング言語で、Javascriptの代替として開発されています(javascriptにコンパイルされます)。GOTOカンファレンス中に2011年にGoogleによって公開されました。

"こんにちは世界!" バリアント:

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

アスキーアートN:

Bruteforceメソッドは、0(n²)で実行されますが、巨大な数字を使用しない限り、それは実際には問題ではありません。

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

GCD

Snapから移植されたシンプルなEuclidメソッド!上記の例。

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

5
O(n²)未満で×n ASCIIアートを出力できるとは思いません。
パウロEbermann

@PaŭloEbermann大きなO表記法や複雑さの計算方法にはあまり慣れていませんが、ジュリアの例はO(n²)ではないようです。
-Nzall

@AlexA。println()関数は、n文字のストリングを出力します。関数呼び出しには、実行に少なくともO(n)の時間が必要だと思います。ループ内では、プログラム全体に対してO(n²)です。
パエロエベルマン

@AlexA。Ebermannが話しているのは、print関数にN個の文字列連結操作があるということです。両方の関数でn²文字列の連結を行います。内部ループの繰り返しごとに1回実行します。println()ごとに実行します。
Nzall

1
これがASCIIアートでない場合、Nを表示するのはO(n)です(画面に3行描画します。各行はO(n)、したがってO(n)複雑です)。または、NのレンダリングがO(N)複雑になると言うことができます... hehe
rodolphito

15

2010- さび

Rustは、Mozilla Researchが開発した汎用のマルチパラダイムコンパイル済みプログラミング言語です。「安全で、並行、実用的な言語」になるように設計されており、純粋な機能、並行アクター、命令型手続き型、およびオブジェクト指向のスタイルをサポートしています。ウィキペディア

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

説明:

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

垂直方向(左右のみ)の印刷を処理します |)および対角線(\

タスク3

Euclidean_algorithmの簡単な実装

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

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

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

stdinから2つのスペースで区切られた整数を入力する方法を示すスニペットを追加できますか?
ゼロファイバー

3
Rustは2010年に「作られた」のですか?プログラミング言語のタイムラインそう言うが、実際の記事は、それが唯一の2010年に発表されたことを述べている(実際には2011年までに明らかなように、参照)とそのバージョン0.2が2012年に発売された
EMBLEM

1
@ SampritiPanda、hastebin.com
raw / lapekowogu

1
少しモダンに見える。コンパイラの最初の<s> released </ s>公開作業バージョンでコンパイルできますか?
Vi。

15

2015-マフィンMC

マフィンMCは、2015年2月中旬にFranck Porcher(http://franckys.com)によって書かれたチューリング完全で、面白い(しかし深刻な)機能的でミニマリストなマクロ言語であり、新しいタヒチアンファッションブランドのPrestashopベースのマーチャントサイトに関連するすべての在庫関連操作をパイロットおよび駆動する唯一のフロントエンドコントローラーとして使用するスプレッドシート:Mutiny Tahitihttp ://mutinytahiti.com- もうすぐ開始)。

Muffin MCは、MU tiny F unctionional F lexible IN line M acro C omand言語の頭字語です。

要件を満たすために、Muffin MCのコア機能は、イテレーター遅延評価マルチファンクターstring-productなどの柔軟で効率的な第1クラスの組み込みセマンティック構造を中心に設計されています

Muffin MCは、(実用的な)関数型プログラミングであるFLispとPerlにそのルーツを持っています。再帰性を完全にサポートし(最適化なし)、動的に型指定され、動的にスコープされます(浅いバインディング)。基本的なデータ型のアトム(原子、文字列、数字)以外に、ユーザーに1つのデータ構造のみを提供します:リスト!

マフィンMCリストセマンティクス(のような)は、パワーセットセマンティクスを借用します。

  1. すべてのMuffin MC操作は、空のリストを生成します。
  2. 個々のリスト要素にアクセスすると、常にその要素で構成された1つの値のリストが生成されます(シングルトンと考えてください)。
  3. 空のリストは、リスト操作の中立的な要素です。

これと調和するために、以下が役立つかもしれません:

  • リストは、最大のカーディナリティを持つリストのパワーセットの要素として視覚化できます。
  • リストの要素を、その要素で作成されたシングルトンであるリストのパワーセットの要素として視覚化します。
  • 空のリストを空のセットとして視覚化します。つまり、空のセットのパワーセットの唯一の要素です。

そのため、空のリスト要素にアクセスすると、エラーではなく空のリストが生成されます!実際、Muffin MCは、多くの従来の操作のセマンティクスをそのように拡張することにより、可能な限り少ないエラーをスローしようとします。

タスク1

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

#(...)は、評価されていない引数リストに関数を適用するためのMuffin MCマクロコマンドです。ここsayでは、Perlから借用した組み込み関数です。

#(say 1 2 3 ...) 機能的には同一です map {say $_} (1,2,3,...)

タスク2

関数を定義するascii-art()

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

Ascii-art()の最短作業フォーム(88バイト):

=(f'(=(* x#(2-)I I(*($(x)" ")N)g'(#(.#(I$(x)))))#(say?(#(==$(_1)1)N"N#(map g#(..))N"))))
  • =(var val...)変数を定義または再割り当てするためのMuffin MCマクロコマンドです。

  • $(var)変数の値にアクセスするためのMuffin MCマクロコマンドです。自然にフォーム$(v1 v2 ...)を受け入れて、一度に多くの変数にアクセスします。

  • =(* var1 val1 var2 val2 ...)並列割り当てを処理するためのMuffin MCマクロコマンドの拡張です=(...)

  • 変数_1, _2、...は動的にスコープされ(浅いバインディングメカニズム)、関数の引数にバインドするように自動的に設定されます。Perl5から借用されたシステム変数#(引数の数)と@(引数のリスト)も自動的に設定されます。

  • 関数は、任意の数のMuffin MCステートメントにバインドされた単なる変数です。

この興味深いソリューションは、2つの自然なMuffin MCビルトイン機能を組み合わせることから生まれます。

  1. Muffin MC I(...)マクロコマンド。サイクリングイテレータを定義し、後に関数形式#(my-iterator want-number-of-values)で使用します。

  2. 任意の文字列が与えられた場合、自然変数補間の拡張であるマフィンMC 文字列積構造"F1 F2 F3..."、F iがMuffin MC文字列リテラルまたはMuffin MCマクロコマンド(別名機能形式)のいずれかで、できるだけ多くの文字列を生成します製品cardinal(F1)x cardinal(F2)x ...によって与えられます。

たとえば、2つの値を保持するxa変数(aとb)、およびyが3つの値を保持する別の変数(1 2 3)の場合、文字列の評価は"x=$(x) y=$(y))"6つの異なる値を生成します。

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

これはMUTINYプロジェクトの非常に望ましい特徴マフィンの一つであるMCが設計されたです。

それを実行します !

#(ascii-art 1)

N


#(ascii-art 3)

N N  
NNN  
N N 


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

N   N
NN  N
N N N
N  NN
N   N

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

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

仕組み

私たちのアルゴリズムは以下に基づいています:

ascii-art(n)の呼び出しを考えると、{n = 2p + 1 | p整数、p> = 0}、生成する技術はn文字のn文字列で構成され、その中で最も左と右の2つは固定され、常に同じ「N」です。これにより、中央の文字列のみを生成する際の問題を軽減できます。たとえば、n = 5の場合、次の5つの中間文字列を生成するために除草します。各文字列はn-2文字です(視覚化のためにスペースを「_」に置き換えました)。

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

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


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


    which, once unfolded, yields the infinite ruban : 

        _ _ _ N _ _ _ N _ _ _ N _ _ _ N _ _ _ N _ _ _ N ...
              ^     ^     ^     ^     
        _ _ _ |     |     |     |
              N _ _ |     |     | 
                    _ N _ |     |
                          _ _ N |
                                _ _ _
  • このような中間ストリングは('_' '_' '_' 'N')、3つの5つのグループで4つの要素シーケンスを循環させることで簡単に作成できます。関数の入力であるnを指定すると、そのようなシーケンスはn-2文字'_'で構成され、その後に文字が続き'N'ます。このシーケンスを繰り返すには、Muffin MCの I(sequence)組み込みイテレータ(値の初期シーケンスを永久に循環するイテレータ)内にシーケンスを埋め込む以外に何も必要ありません。

  • 次に、イテレータに次のn-2値(n-2文字)を提供するように要求することにより、長さn-2の中間文字列を生成します。

  • n個の中間文字列は、マップを使用して上記のプロセスをn回繰り返して生成され、n個の結果(n-2文字のn個の文字列)を収集します。

  • もう1つの強力なMuffin MC組み込み構造、つまり文字列積を使用して、最終的なn個の文字列を生成します"N#(map...)N"

  • 以上です !

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

タスク3

関数を定義するgcd()

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

gcd()実際の最短形式(37バイト- 2バイトがRodolverticeのおかげでゲイン)

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

それを実行します !

#(gcd 225 81)

収量9。

それでおしまい。

素敵なゲーム、そしておそらくあなたの興味をありがとう。この言語は、遊んだり、使用したり、拡張したりしたい人なら誰でも利用できます。ちょうどそれを頼むと私はそれを送ってうれしいです。

乾杯

フランク


PS。Muffin MCの現在の実装はPerl5です。ソースコードはコメントを含む約2000行の近代的なPerlであり、非回帰テストスイートがバンドルされています。これは、実践的なMuffin MCの構造とセマンティクスを学ぶのに最適です。


すごくいい!ascii-artの最短形式には短縮された関数名がありますが、GCD最短版にはありません。これは意図的なものですか。そうでない場合は、さらに2バイト削ることができます。+1
ロドルフィト

確かに、それは意図的なものです。したほうがいい ?はい、やってみましょう;)投稿と感謝をありがとう。
フランクポルシェ

1
余分な文字を削除しようとしているので(そして、私は文法的に扱いにくいため、最初のタスクでは感嘆符の前のスペースを削除する必要があります)。このスペースはフランス語では正しいですが、英語では正しくありません。
アモスM.カーペンター
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.