プログラミング入門
Fibonacci
プログラミング言語比較
プログラミング言語

【まとめ】フィボナッチ数だけで40以上のプログラム言語に精通したつもりになる

フィボナッチ数だけでプログラム言語に精通したつもりになる

簡単なサンプルでプログラム言語の基本をおさえる

フィボナッチ数を求めるプログラムで各言語の基本仕様をマスターしたつもりになります。
Hello World!の次にやってみればいいと思います。
サンプルでは、

  • 変数の宣言とか代入(束縛)とかスコープとか
  • コマンドライン引数の取得
  • 文字列から数値への変換
  • 関数定義と呼び出し
  • 再帰関数の利用
  • 条件分岐
  • 文字列(数値)の表示
  • コメント文の書き方
  • 大まかな実行速度

上記を一気に知ることができます。あら便利。

progopedia や似たような記事はありますが、すべてが同じアルゴリズムで、コマンドラインで動くプログラムとして完結しているものは少なかったので、まとめてみました。

フィボナッチ数とは

めんどくさいので詳しいことはWikipediaで調べてください。
ここでは簡単に書きます。
定義は、
41.png

一般項の近似式は、
45.png
70.png

漸化式の行列表現は、
44.png

今回は頭の悪い再帰関数を使って定義通りに39番目のフィボナッチ数「63,245,986」を計算します。

サンプルプログラム

書き方について

各言語、もっといい書き方はあるとは思いますが、なるべく方言が出ないように書いています。
そのためにその言語の標準的な書き方になっていなくて、その言語の特徴を知るということに対しては本末転倒なことになっている場合もあります。
コマンドライン引数から計算するようになっているため、最適化されて固定値を表示するだけのプログラムにはなっていません。

サンプルの順序

大体TIOBEの2016年1月の人気順位で書いてます。
途中知らない言語を飛ばしたり、CとJavaを入れえちゃったりしていますが。

解説について

ものすごく個人的な偏見や誤解、思い込みに満ちた解説です。
解説中ではネイティブコードとか中間コードとかにはこだわらず、雑に
コンパイルが必要な言語→コンパイル言語とかコンパイラとか
コンパイルが不要な言語→スクリプト言語とかインタプリタとか
と定義しています。
「言語とコンパイラは違うだろ。」とかつっこまれそうですが、まぁなんとなく、で。

今後の予定

追加予定の言語

  • Io

ABC順のインデックス

C

とりあえずお約束ということで、C言語から行きます。
多分、世界標準です。
速いし、ライブラリも豊富だし、正直これだけ知っていれば何でもできます。
と言ってしまえば、この記事の存在が危ぶまれますが。
これぐらいのプログラムであれば、PHP や JavaScript しか触ったことのない人でもわかると思います。
ポインタを理解できるかがどうかがこの言語の鍵です。

fib_c.c
// フィボナッチ数
#include <stdio.h>
#include <stdlib.h>

int fib(int n)
{
    if (n < 2) {
        return n;
    } else {
        return fib(n-1) + fib(n-2);
    }
}

int main(int argc, char *argv[])
{
    int n;
    n = atoi(argv[1]);
    printf("%d", fib(n));
    return 0;
}

/*
Example
    compile:
        gcc -O3 -o fib_c fib_c.c
    run:
        ./fib_c.c 39
*/

<近似式でやっつけ>
long long int なので92以下しかダメですが、計測不能なタイムで瞬殺です。

fib_binet.c
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main(int argc, char *argv[])
{
    printf("%lld", (long long int)(pow(((1+sqrt(5))/2),atof(argv[1]))/sqrt(5)+0.5));
    return 0;
}
/*
Example
    compile:
        gcc -O3 -lm -o fib_binet fib_binet.c
    run:
        ./fib_binet 92
*/

Java

これまたこの業界にいて名前を知らない人はいないと思います。
昔は遅い遅いと言われましたが、JITが効くようになってからは、C言語に迫る速度です。
この言語もライブラリが豊富で、これだけでほぼ何でもできます。
この言語で開発するための時間の殆どは、クソみたいに階層の深いライブラリのどこに何があるかを探すことに費やすことです。
書き方がちょっと冗長なのが嫌いなところです。
JITで充分速いので、GNUのJavaのコンパイラgcjはもういらない子かも…。

fib_java.java
// フィボナッチ数 by java
public class fib_java {
    public static int fib(int n) {
        if (n < 2) {
            return n;
        } else {
            return fib(n-2) + fib(n-1);
        }
    }
    public static void main(String[] args) {
        int n = Integer.parseInt(args[0]);
        System.out.println(fib(n));
    }
}

/*
    example
        compile by OpenJDK:
            javac fib_java.java
        run by OpenJDK:
            java fib_java 39
        compile by gcj:
            gcj -O4 --main=fib_java -o fib_gcj fib_java.java
        rub by gcj:
            ./fib_java 39
*/

C++

C言語にオブジェクト指向を取り込んだ魔物。
この言語のダークサイドに陥れば、クラス継承の無間地獄が味わえます。
さすがに速度はC同様に高速。

fib_cpp.cpp
// フィボナッチ数 by C++

#include <iostream>
#include <cstdlib>

using namespace std;

int fib(int n)
{
    if (n < 2) {
        return n;
    } else {
        return fib(n - 1) + fib(n - 2);
    }
}

int main(int argc, char** argv)
{
    int n;
    n = atoi(argv[1]);
    cout << fib(n) << endl;

    return 0;
}

/*
example
    compile:
        g++ -o fib_cpp -O3 -mtune=native fibonacci.cpp
    run:
        ./fib_cpp 39
*/

C#

Microsoft謹製のC言語もどき。
C言語とJavaを足して割ったような仕様。
VisualBasicよりもすっきりした書き方ができ、Windows界隈では標準になりそうな勢い。
Monoを利用すればLinuxでもコンパイルと実行が可能。
Windowsで速度比較をやっていないが多分高速。
LinuxではMonoに依存するのでなんとも言えませんが、スクリプトよりは速い。
いや、個人的には嫌いではないんですがね。

fib_cs.cs
// C#でフィボナッチ
using System;

class Fibonacci
{
    static long Fib(int n)
    {
        if (n < 2)
            return n;
        else
            return Fib(n - 2) + Fib(n - 1);
    }

    static void Main(string[] args)
    {
        int n = int.Parse(args[0]);
        Console.Write(Fib(n));
    }
}

/*
example
    compile:
        mcs -optimize+ fib_cs.cs
    run:
        mono fib_cs.exe 39
*/

Python

いきなりスクリプト(インタプリタ)言語。
この言語の特徴はなんと言っても、インデントでブロックが決定すること。
誰が書いても綺麗に見えるプログラムが書けます。
ただし中途半端にインデントつけてくれるエディタで編集すると、一発で修復不可能な状態まで破壊されちゃいます。
実行速度は遅い。バージョンが2→3になって更に遅くなりました。
ってか、微妙に互換性がない!勘弁してください。
pypyとかは名前がいやらしいので試していません。
なぜか海外では人気。

昔「psp」と言ってPHPに対抗してHTMLに埋め込む形式のPythonがありましたが、想像通りHTMLのインデントと混ざり合い混沌したソースになってしまい普及しなかったのはPythonの黒歴史。

fib_py.py
# -*- coding: utf-8 -*-
# フィボナッチ数 by Python

import sys

def fib(n):
    if n < 2 :
        return n
    else:
        return fib(n-2) + fib(n-1)

argv = int(sys.argv[1])

print(fib(argv))

"""
example
    run:
        python fibonacci.py 39
"""

php・Hack

みんな大好きphp。
適当に書いてもそこそこ動くために、糞コードが繁殖しやすい。
php-7がリリースされて、速度はほぼ2倍に。Rubyとほぼ同じ速度。
でもphp互換のhhvmはChromeのV8並みに速い。
ロジックだけのphpのファイルの場合、後ろの「?>」はつけないのが流行りらしい。
たしかに、余計な改行に悩まされなくて良さそう。

fib_php.php
<?php
/**
 * フィボナッチ数だよ
 * @param int $n
 * @return int
 */
function fib($n) {
    if ($n < 2) {
        return $n;
    } else {
        return fib($n-2) + fib($n-1);
    }
}

print fib($argv[1]);

/*
example
    run:
        php fib_php.php 39
*/

hhvm で型を指定して書くと「Hack」になります。
だからと言って、普通のhhvm より速いということはなく、どちらかといえばバグ防止?
phpぽくない。けどphpよりはかっこいい。

fib_php.hh
<?hh
/**
 * フィボナッチ数だよ
 * @param int $n
 * @return int
 */
function fib(int $n): int {
    if ($n < 2) {
        return $n;
    } else {
        return fib($n-2) + fib($n-1);
    }
}

print fib(intval($argv[1]));

/*
example
    run:
        hhvm fib_php.hh 39
*/

Basic

VB.Net

Microsoft仕様のBasic。
高機能になり過ぎて、書き方がすごく冗長になってしまいました。
最近はC#に人気を奪われつつある?
Monoで試しました。
速度はMonoに依存するため、MonoのC#とほぼ同じ。昔はすっげぇ遅かったけど。

fib_vb.bas
' フィボナッチ数 by Visual Basic
Module Fibonacci

    Function Fib(ByVal N As Integer) As Integer
        If N < 2 Then
            Return N
        Else
            Return Fib(N - 2) + Fib(N - 1)
        End If
    End Function

    Sub Main(ByVal CmdArgs() As String)
        Dim N As Integer = Integer.Parse(CmdArgs(0))
        Console.WriteLine(Fib(N))
    End Sub

End Module

' example
'   compile:
'       vbnc /optimization+ /out:fib_vbnc.exe fib_bas.bas
'   run:
'       mono fib_vbnc.exe 39

FreeBasic

知名度は低いが、何気にクソ速い。
GNU コンパイラコレクションに含まれることを画策している模様。
GNU Cより速いことがあります。

fib_fbc.bas
' フィボナッチ数 by FreeBasic
Function Fib(N As Integer) As Integer
    If N < 2 Then
        Fib = N
    Else
        Fib = Fib(N - 2) + Fib(N - 1)
    End If
End Function

Dim N As Integer = ValInt(Command(1))
Print Fib(N)

' example
'   compile:
'       fbc -O 3 fib_fbc.bas
'   run:
'       ./fib_fbc 39

JavaScript

JQUERY のおかげ(だけ?)でWEBには欠かせない言語となりました。
とは言うものの、他の言語では少ないprototypeの概念や、関数型言語っぽい機能もあり、非常に興味深い言語。
GoogleとMozillaで開発競争をしているため、最近のJavaScriptはクソ速い。
Google→Chrome→V8
Mozilla→FireFox→Spidermonkey

サーバサイドで使用するnode.jsという実装もあります。
ちょっと期待している、サーバサイドとクライアントサイドで同じ言語が使えるというのは、学習コストの低減に繋がりそうだが、どのロジックがどっちで動いているのか混乱しそうで悪い予感しかしません。

サンプルは、V8、node、Spidermonkey で動くように書いてみました。
なんかd8コマンドでコマンドライン引数を取得することができなかったので、固定値で妥協。

fib_js.js
// フィボナッチ数 by JavaScript

var fib = function(n) {
    if (n < 2) {
        return n;
    } else {
        return fib(n-1) + fib(n-2);
    }
}

if (typeof process === "undefined" && typeof scriptArgs !== "undefined") {
    // for Spidermonkey
    print(fib(scriptArgs[0]));
} else if (typeof process !== "undefined") {
    // for node
    console.log(fib(process.argv[2]));
} else {
    // for d8
    print(fib(39));
}

/*
example
    Spidermonkey:
        js fib_js.js 39
    Node.js:
        node fib_js.js 39
    v8:
        d8 fib_js.js
*/

Ruby・Crystal

Ruby

Rubyは日本製のスクリプト言語。おかげで日本での人気は高く日本語のドキュメントが多い。
とはいうものの、実務でRubyというのは意外と少ない。
言語おたくにより設計されているため、プログラマが好きそうな機能がたっぷり実装されています。
書き方には寛容なところがメリットでありデメリットでもあります。
Ruby on Rails で人気爆発したが、個人的にはRoLは実装が重い印象があり、あまり好きではありません。
Ruby自体は好き。
バージョンを追うごとに速くなっています。phpと速度競争をしてる?

fib_rb.rb
# フィボナッチ数
def fib(n)
    if (n < 2)
        return n
    else
        return fib(n - 2) + fib(n - 1)
    end
end
puts fib(ARGV[0].to_i)

=begin
example
    ruby fib_rb.rb 39
=end

Crystal

CrystalはRuby風の文法のコンパイラ言語。開発元は違います。
Rubyほど文法に寛容ではないため、Rubyでだらしない書き方をしていると怒られます。
ライブラリ経由でCの関数が呼べたりする。めっちゃ速い。
本気のJavaとほぼ同じ速度の最近ちょっと気になる言語。
Rubyのプログラムがほぼそのまま動きそうですが、=begin〜=end形式のコメントブロックでエラーが出てしまいました。

fib_rb.rb
# フィボナッチ数
def fib(n)
    if (n < 2)
        return n
    else
        return fib(n - 2) + fib(n - 1)
    end
end
puts fib(ARGV[0].to_i)

#
# example
#    compile:
#        crystal compile --release -o fib_crystal fib_rb.rb
#    run:
#        ./fib_crystal 39
#

Perl

Perl5

CGIで一時は世界を征服した言語。
正規表現による強力な文字列操作が特徴。
恐ろしく省略できるため、自分が書いたプログラムでも4歩歩けばわからなくなります。
よって鶏に開発は無理。
実装が古く速度は遅い。
しかしPerl形式の正規表現は他の言語に受け継がれています。

fib_perl.pl
# フィボナッチ数 by Perl
sub fib
{
    my $n = shift;
    if ($n < 2) {
        return $n;
    } else {
        return fib( $n - 2 ) + fib( $n - 1 );
    }
}

print fib($ARGV[0]);

=pod
example
    perl fib_perl.pl 39
=cut

Perl6

出る出ると言われてなかなか出てこない次世代型Perl。
Perl6 で書かれたプログラムをrakudo というコンパイラが Moar VM のバイトコードに変換します。
まだ実験段階らしく速度はシェル並に遅い。
Perl5との互換性も低くなかなか使いどころがない。

fib_perl.pl6
# フィボナッチ数 by Perl
sub fib ($n)
{
    if ($n < 2) {
        return $n;
    } else {
        return fib( $n - 2 ) + fib( $n - 1 );
    }
}

my $ARGV = @*ARGS.shift;

print fib($ARGV);

=pod
example
    perl6 fib_pl.pl6 20
=cut

Pascal

かつては「アルゴリズムを勉強するならコレ」と言われた言語。
begin〜end形式が好きな人にはたまらない言語。
Delphiが消え、そこそこ使えそうなのはFree Pascal Compilerぐらい。
Free Pascal Compiler は、古いPascalの他、DelphiモードやObjectPascalモードでのコンパイルも可能。
ただ、生成されたバイナリにランタイムがくっつくので、ファイルが大きくなりがち。
最適化もいまいち。
でも個人的には愛着のある言語です。

fib_pascal.pas
uses sysutils;

function fib(n:longint): longint;
begin
     if (n < 2) then
          fib := n
     else
          fib := fib(n - 2) + fib(n - 1);
     end;

var
     n : integer;
begin
     n := StrToInt(ParamStr(1));
     writeln(fib(n));
end.

(*
     example
    compile(Free Pascal Compiler):
     fpc -O4 -Tlinux fib_pascal.pas
*)

Swift

2016年にブレイクしそうな言語。Mac OSXのXcodeに採用されました。
ちょっと関数型言語っぽい仕様なのでクセがあります。
たぶんClangを使っていそうなので速度もClangでコンパイルされたCとほぼ同じ。
これが出たことでObjective-Cの立場が微妙になりそう。

fib_swift.swift
// フィボナッチ数 by swift
func fib(n: Int) -> (Int) {
    if n < 2 {
        return n
    } else {
        return fib(n - 2) + fib(n - 1)
    }
}

var n = Int(Process.arguments.suffixFrom(0)[1])!
print(fib(n))

/*
example
    JITmode:
        swift fib_swift.swift 39
    compile:
        swiftc -O -o fib_swift fib_swift.swift
    run:
        ./fib_swift 39
*/

Octave・Scilab

なんでいきなり数値計算システムが出てきたかというと、TIOBEでは、この位置に「MATLAB」が来ていたため。
というか普通の言語が続いたので、少し気分転換に。
肝心のMATLABが手元にないため、Octave、Scilabでお茶を濁します。
さすがは数値計算が専門の言語。
数値演算のプログラムはすっきり書けます。
ただし、実効速度は遅い。
あと、Scilabをコマンドラインから引数を取得して実行する方法は調査中。

Octave

fib_octave.m
# フィボナッチ数 by Octave
function f  = fib(n)
    if (n<2)
        f = n ;
    else
        f = fib(n - 2) + fib(n - 1);
    endif
endfunction

args = argv();
printf("%d", fib(str2num(args{1})));

#{
    example
        run:
            octave-cli -qf fibonacci.m 20   
#}

Scilab

fib_scilab.m
-->function f  = fib(n)
-->    if n < 2 then
-->        f = n
-->    else
-->        f = fib(n - 2) + fib(n - 1)
-->    end
-->endfunction

-->fib(20)
 ans  =

    6765. 

Groovy

なまけものの為のJava。Javaが故にJavaとの親和性も高い。
コンパイルしなくても動いちゃう。変数の型とか指定しなくても動いちゃう。
でも真面目に型指定とかしてあげるとちゃんと高速で動きます。
嫌いじゃないけど、クセがなさすぎて使いどころに迷います。
でも、int をIntegerって書いちゃうとすごく遅くなったりとか、しれっと罠が潜んでいるので注意。

fib_groovy.groovy
// フィボナッチ数 by groovy
int fib(int n) {
    if (n < 2) {
      return n;
    } else {
      return fib(n - 2) + fib(n - 1);
    }
}

int n = Integer.decode(args[0]);
println fib(n);

/*
example
    run source code:
        groovy fib_groovy.groovy 39
    compile:
        groovyc fib_groovy.groovy
    run byte code:
        groovy fib_groovy 39
*/

R

数値計算用言語。
と言っても行列とか集計とかが書きやすいってだけで、ゴリゴリの数値演算は遅い。
速度を求めるなら、CとかFortanとか使いなさいということだと思います。多分。
ググりにくい。

fib_r.r
# フィボナッチ数 by R
fib <- function(n) {
    if (n < 2)
        return(n)
    else
        return(fib(n - 2) + fib(n - 1))
}

argv <- commandArgs(TRUE)
n <- as.integer(argv[1])

cat(fib(n))

# example
#   run:
#       Rscript fibonacci.R 30

D

Cの置き換えを目指して作られた言語(だと思います)。
C++やJavaのいいとこ取りをして高機能にしたら、実装が追いついていない印象。
来るぞ来るぞと言われて一向に来ない。
本家のコンパイラより、GNUのコンパイラの方が速い始末。

fib_d.d
// フィボナッチ数 by D

import std.stdio;
import std.conv;

int fib(int n) {
    if (n < 2) {
        return n;
    } else {
        return fib(n - 2) + fib(n - 1);
    }
}

void main(string[] args) {
    int n = to!int(args[1]);
    writeln(fib(n));
}

/*
example
    compile:
        dmd fib_d.d -O -inline
        gdc -O3 fib_d.d
    run:
        ./fib_d 39
*/

FORTRAN

今回のフィボナッチ数の演算では最速をマークした言語。GNUのコンパイラではCより速い。
歴史の古さ、性能の高さ、難解そうなイメージ、スパコンでの実績など文句なく最強言語の一つ。
実はBasicはFortranを簡単にしたものなので、初見でもなんとなく読める言語。
古い実装ゆえ、最近流行りの機能はあまりありませんが、そこが魅力。
FORTAN90で書いてみました。

fib_fortan.f90
program main
    implicit none
    character(255) a
    integer n
    call getarg(1, a)
    read(a,*) n
    print *, fib(n)
contains
    recursive integer function fib(n) result(ret)
        integer n
        if (n < 2) then
            ret = n
        else
            ret = fib(n-2) + fib(n-1)
        end if
    end function fib
end program main

! compile example
!   gfortran -o fib_fortran -O3 fibonacci.f90

Dart

最近気になる言語No.1(調査人数1人)。
スクリプト言語の中ではダントツに速い。ヘタなコンパイル言語に匹敵する速さ。
静的型付け言語。

fib_dart.dart
// フィボナッチ数 by Dart
int fib(num n) {
    if (n < 2) {
        return n;
    } else {
        return fib(n - 2) + fib(n - 1);
    }
}

void main(List<string> arguments) {
    int n = int.parse(arguments[0]);
    print(fib(n));
}

/*
 example
    run:
        dart fibonacchi.dart 39
*/

Lisp

難解そうなイメージではトップクラスの関数型言語。
憧れはあるのだが、いつもカッコの多さの前にくじけてしまう。
Steel Bank Common Lisp で試してみました。
Clispで動くようにもしてみたつもりだけど試していません。

fib_lisp.cl
(defun args()
    #+sbcl sb-ext:*posix-argv*
    #+clisp ext:*args*
)

(defun fib (n)
    (if (< n 2)
        n
        (+ (fib (- n 2)) (fib (- n 1)))
    )
)

(defun main()
    (print (fib (parse-integer (nth 1 (args)))))
)

(main)
#|
example
    run:
        sbcl --script fib_lisp.cl 39
|#

Ada

アメリカ国防総省の要求により開発された超硬派言語。
歴史は古いがパッケージ等の概念があります。
あまりに文法に厳密にしたため、一般うけしませんでした。
今でも使われているのでしょうか?
GNUではgnatとして実装されています。GNU Cよりも速いことがあります。

fib_ada.adb
with
    Ada.Integer_Text_IO,
    Ada.Command_Line;

use
    Ada.Integer_Text_IO,
    Ada.Command_Line;

procedure fib_ada is
    N : Integer := Integer'value(Argument(1));

begin
    declare
        function fib (n : Integer) return Integer is
        begin
            if n < 2 then
                return n;
            else
                return fib(n - 2) + fib(n - 1);
            end if;
        end fib;

    begin
        Put(fib(N), 1);
    end;
end fib_ada;

-- example
--  compile
--      gnatmake -O3 fib_ada.adb

Scratch

MITによって開発されたブラウザ上で動作する言語。
本当は教育用でタートルグラフィックスとかをやる言語だと思いますが、数値演算もできないではありません。
JavaScriptを呼び出せるので、本当はそっちでやるべきだと思います。
ダウンロードしてローカル環境で遊ぶこともできる。癖になると楽しい。
Scratch本家ではなく、Snap!というサイトで遊んでみました。
Spidermonkeyのおかげだと思うが、Octaveより速い。

57.png

Scala

Java で実装された関数型言語。
インタプリタのオーバーヘッドが大きいのか、軽い処理が遅い。
重い処理では限りなくJava の速度に近づく。
文法はかなりすっきりしています。
関数でパターンマッチングが使えるのは素敵ですが、if の方が速いのが残念。

fib_scala.scala
// フィボナッチ by Scala
object fib_scala {
    def fib(n: Int): Int =
        if (n < 2)
            n
        else
            fib(n - 2) + fib(n - 1)

    /* こっちが遅い
    def fib(n: Int): Int = n match {
        case 0 => 0
        case 1 => 1
        case _ => fib(n - 2) + fib(n - 1)
    }
    */

    def main(args: Array[String]) = {
        var n = Integer.parseInt(args(0))
        println(fib(n))
    }
}

/*
example
    run as script:
        scala -Onone fib_scala.scala 39
    compile:
        scalac -optimise -target:jvm-1.8 fib_scala.scala
    run as byte code:
        scala 
*/

Prolog

日本のコンピュータ業界で口にしてはならない言葉があります。
それが「Σ計画」と「第5世代コンピュータ」です。
その「第5世代コンピュータ」を開発するにあたって中核を担っていた言語がPrologです。
別に日本産の言語っていうわけではないです。
そういうわけで不遇なPrologですが、「論理型言語」という特徴的なパラダイムの言語です。
誤解を恐れずに超簡単に省略すると、
「命題を宣言していったら、質問に答えてくれるようになるんじゃね?」
って感じでプログラミングしていきます。

現状、「実用的か?」って聞かれたら即答で「無理。」ですが、研究や学習対象としては非常に面白い言語です。

うっかりするとメモリをバカ食いします。
そもそもこんな計算させるなって話ですが。

GNU Prolog (gprolog)

環境変数GLOBALSZとかTRAILSZとかでメモリ設定しないと大きな引数で動きません。
Prologのソースコードの標準の拡張子が「.pl」なため、Perlと衝突します。
インタプリタはPerlより少し高速で、コンパイルするとRuby程度の速さになります。

fibonacci.pl
% フィボナッチ数 by GNU Prolog
fib(0,0).
fib(1,1).
fib(X,Y) :-
    X > 1,
    X2 is X - 2, fib(X2, Y2), !,
    X1 is X - 1, fib(X1, Y1), !,
    Y is Y1 + Y2.

main :- current_prolog_flag(argv, Argv),
    nth0(1, Argv, Param),
    number_atom(N, Param),
    fib(N, X),
    write(X),
    nl,
    halt.

:- initialization(main).

% exapmle
%   interpreter:
%       export GLOBALSZ=262144;export TRAILSZ=262144; gprolog 30 --consult-file fibonacci.pl
%   compiler:
%       gplc fibonacci.pl
%       export TRAILSZ=1048576; ./fibonacci 39

Lua

流行るかなと思わせておいて、なかなか流行らない言語。
知らない間にluajit とか出てるし、速い。
あまりクセのない文法。

fib_lua.lua
-- フィボナッチ数
function fib(n)
    if n < 2 then
        return n
    else
        return fib(n - 2) + fib(n - 1)
    end
end

n = tonumber(arg[1])
print(fib(n))

--[[
example
    lua fib_lua.lua 39
    luajit fib_lua.lua 39
--]]

F#

Microsoft Visual Studio の異端児。関数型言語。
異端児が故にドキュメントも少ない。何人使っているのでしょうか。
関数型言語らしく、関数ではパターンマッチが使えます。
フィボナッチ数を求める以外に使いみちがわかりません。

fib_fs.fs
// フィボナッチ数 by F#
(* if else
let rec fib n = 
    if n < 2 then
        n
    else
        fib(n - 2) + fib(n - 1)
*)
let rec fib = function
    | n when n=0 -> 0
    | n when n=1 -> 1
    | n -> fib(n - 2) + fib(n - 1)

[<EntryPointAttribute>]
let main (args) = 
    //printf "%d" (fib(10))
    let n : int = int args.[0]
    printf "%d" (fib(n))
    0

(*
    example
        compile:
            fsharpc --optimize+ fib_fs.fs
        run:
            mono fib_fs.exe 39
*)

Haskell

硬派な関数型言語。硬派といってもLispほどカッコ地獄に陥らない。
個人的には好き。でも使いこなせない自分がはがゆい。

fib_haskell.hs
-- フィボナッチ数 Haskell版
import System.Environment (getArgs)

fib :: Int -> Int
fib n
    | n < 2 = n
    | otherwise = fib(n - 2) + fib(n - 1)

main = do
    argv <- getArgs
    let n = read (argv !! 0) :: Int
    print $ fib n

{-
example
    compile:
        ghc -O -o fib_haskell fib_haskell.hs
    run:
        ./fib_haskell 39
-}

zipWithを使ってずらしたリストを合成していく方法 -- bra_cat_ket様ありがとうございます。
(たぶんこっちがHaskellらしい書き方)

fib_haskell2.hs
-- フィボナッチ数 Haskell(zipWith)版
import System.Environment (getArgs)

fib :: Int -> Integer
fib n = fibs !! n

fibs :: [Integer]
fibs = 0:1:zipWith (+) fibs (tail fibs)

main = do
    argv <- getArgs
    let n = read (argv !! 0) :: Int
    print $ fib n

Erlang

下手な説明をするとすごい人に怒られてしまいそうなアーラン。
動的型付けな関数型言語です。
並列処理思考で分散処理指向で…。
すみません、もうこれぐらいで勘弁してください。怒らないでください。
起動するのに1秒程度オーバーヘッドがあるのがつらいとか、
バイトコードの拡張子が「.beam」ってだっせぇとか、
言いませんからごめんなさい、ごめんなさい。
汚いコード晒してごめんなさい。

fibonacci.erl
% フィボナッチ数 by Erlang
-module(fibonacci).
-export([main/1]).

main(Arg) ->
    N = fib(list_to_integer(hd(Arg))),
    io:fwrite(integer_to_list(N)).

fib(0) -> 0;
fib(1) -> 1;
fib(N) -> fib(N - 2) + fib(N - 1).

% example
%    compile:
%        erlc fibonacci.erl
%    run:
%        erl -noshell -run fibonacci main 39 -run init stop

Rust

Mozillaによって開発されている並列処理が得意な言語。
でもフィボナッチ数には並列処理は不要。
Swiftを凌ぐ速度を出しながら、いまいち注目されない言語。
しかもちょっと似ています。

fib_rust.rs
// フィボナッチ数 by rust
use std::env;

fn fib(n: i64) -> i64 {
    if n < 2 {
        n
    } else {
        fib(n - 1)  + fib(n - 2)
    }
}

fn main() {
    if let Some(s) = env::args().nth(1) {
        if let Ok(n) = s.parse::<i64>() {
            println!("{}", fib(n))
        }
    }
}

/*
 example
    compile:
        rustc -C opt-level=3 fib_rust.rs
    run:
        ./fib_rust 39
*/

これより以下はTIOBEのランキング外の言語

Go

Google謹製の言語。最近はあまりニュースがありません。
いい言語なんですけどね。
依存するライブラリがなくシングルバイナリで実行できるようになるのが何気にすごい。

<再帰関数版>

fib_go.go
// フィボナッチ数 by Go
package main

import "fmt"
import "flag"

func fib(n int) int {
    if n < 2 {
        return n
    } else {
         return fib(n-2) + fib(n-1)
     }
}

func main() {
    var n = flag.Int("n", 0, "usage")
    flag.Parse()
    fmt.Println(fib(*n))
}

/*
 example
    compile:
        go build fib_go.go
    run:
        ./fib_go -n 39
*/

<メモ化関数版>TakaakiFuruse 様ありがとうございました。

fib_go.go
// フィボナッチ数 メモ化 by Go
package main

import "fmt"
import "flag"

func calcFib(n int) int {
    fib := []int{0, 1}
    for i := 1; i < n; i++ {
        f := fib[len(fib)-1] + fib[len(fib)-2]
        if f == n {
            break
        }
        fib = append(fib, f)
    }
    return fib[len(fib)-1]
}

func main() {
    var n int
    flag.IntVar(&n, "n", 0, "usage")
    flag.Parse()
    fmt.Println(calcFib(n))
}

/*
 example
    compile:
        go build fib_go.go
    run:
        ./fib_go -n 39
*/

julia

C、C++、Scheme で実装されたちょっと関数型言語。
Google V8 と同等の速さ。
VM の起動の遅さを抱えていましたが、最近はかなり改善されています。
研究者(なんの?)の間でじわじわと人気を上げているらしいです。

fib_julia.jl
# フィボナッチ数 by julia
function fib(n)
    if n < 2
        return n
    else
        return fib(n - 2) + fib(n - 1)
    end
end

n = parse(Int32, ARGS[1])
println(fib(n))

#=
example
    julia -O fibonacci.jl -- 39
=#

Maxima

Mathematica に似た数式処理システム。
今回のサンプルの中では唯一組み込み関数でfib()が存在していました。
コマンドライン引数の渡し方がわからなかったのでevalに相当するものを渡すという危険なやり方で妥協。

fib_maxima.m
/* フィボナッチ数 by Maxima */
fib(n) := if n < 2 then n else fib(n - 2) + fib(n - 1);

/*
example
    run:
        maxima --very-quiet --init-mac fibonacci.mac --batch-string="fib(10);"
*/

<いやぁ、組み込み関数あるんだからプログラム書かなくていいんじゃね?版>

maxima --very-quiet --batch-string="fib(10);"

これなら、引数が100でも1000でも一瞬で結果がでます。

Wolfram (Mathematica)

教育向け数式処理界では最強と噂のMathematica。
一般向けライセンスが高価なため学校の授業以外ではあまり使われていません。
<再帰関数版>

fib_mathematica.m
(* フィボナッチ数 by wolfram *)
fib[0] := 0
fib[1] := 1
fib[n_] := fib[n - 2] + fib[n - 1]

n = ToExpression[$ScriptCommandLine[[2]]]
Print[fib[n]]

(* Example *)
(* Run: *)
(*  WolframScript -script fibonacci.m 30 *)

<メモ化関数版>
再帰関数をちょっといじっただけ。こういうところが関数型言語の楽しいところ。

fib_mathematica.m
(* フィボナッチ数 by wolfram *)
fib[0] := 0
fib[1] := 1
fib[n_] := fib[n] = fib[n - 2] + fib[n - 1]

n = ToExpression[$ScriptCommandLine[[2]]]
Print[fib[n]]

(* Example *)
(* Run: *)
(*  WolframScript -script fibonacci.m 30 *)

Nim(旧Nimrod)

日本語版のWikipediaが無いという珍しい言語(2016年1月現在)
(2016年8月、Wikipediaに追加されたようです。)
C経由でネイティブコードを吐くらしいのですが、何故かCより速かったりします。
いつか使いたい。いつかね。

fib_nim.nim
# フィボナッチ数 by Nim
import os
import strutils

proc fib(n: int): int =
    if n < 2:
        return n
    else:
        return fib(n - 2) + fib(n - 1)

var n = parseInt(paramStr(1))
echo(fib(n))

discard """
    example
        compile:
            nim compile --opt:[none|speed|size] fib_nim.nim
        run:
            ./fib_nim 39
"""

OCaml

海外ではなぜか人気のない関数型言語。
スクリプトモードでもそこそこ速いけど、ocamlopt でネイティブコードにコンパイルするとめっさ速くなる。
Ocaml を使ってWEBサイトを立ち上げるのが夢。

fib_ocaml.ml
(* フィボナッチ数 by OCaml *)
let rec fib(n) =
    if n < 2 then
        n
    else
        fib(n - 2) + fib(n - 1)
    ;;

let n = int_of_string Sys.argv.(1);;
print_int(fib n);;

(* example
    interpreter:
        ocaml fib.ml
    compile:
        ocamlc -o fib_ocaml fib.ml
    compile (native):
        ocamlopt -o fib_ocamlopt fib.ml
*)

Smalltalk

歴史は古く他の言語のモデルとされながらも、クセの強い文法が個性的なため普及しているとは言いがたい。
単なる言語だけではなく「Smalltalk環境」としての実装されてきたため、一般のプログラミング言語のような普及の仕方ではありません。
その「環境」を完全に無視したGNU Smalltalk で試してみました。

fib_gst.st
"フィボナッチ数 by Smallalk"
Integer extend [
    fib [
        self < 2
        ifTrue: [ ^self ]
        ifFalse: [ ^(self - 2) fib + (self - 1) fib ].
    ]
]

Smalltalk arguments first asInteger fib printNl.

"example
    run:
        gst fibonacci.st -a 39
"

Forth

スタック型言語。後置記法になるため、ぱっと見何が書いてあるのかわからないコンピュータに優しい言語。
これが書けたらみんなから「変態」の称号がもらえるありがたい言語。

fib_forth.fs
\ フィボナッチ数 by forth

: fib ( n )
    dup 2 u< if exit then
    1- dup recurse swap 1- recurse + ;

fib . cr
bye

(
    example
        run:
            gforth -e 39 fibonacci.fs
            gforth-fast -e 39 fibonacci.fs
)

Mind

スタック型言語の特徴をうまく(?)利用した日本語によるプログラミング言語。
「ぴゅう太日本語BASIC」以来の衝撃を受けた言語。
しばらく開発が止まっていましたが、最近Androidで動かすプロジェクトがあるらしいです。

fib_mind.src
(フィボナッチ by Mind)

フィボナッチとは (数値 → 数値)
    値1は 変数
    値1に 入れ
    値1が 1 以下 ならば
        値1を 返す
    さもなければ
        値1から 2を 引き フィボナッチし
        値1から 1を 引き フィボナッチし
        足して 返す
    つぎに
    。

メインとは
    起動引数(1)を 数値変換して 真? ならば
        フィボナッチして
        数値表示
    つぎに
    。

※example
※   compile:
※      mind fib_mind.src file
※   run:
※       ./fib_mind 39

APL

ネタ言語(Brainf**k等)を除き、変態度では他の追随を許さないプログラミング(?)言語。
特殊な記号を多用するため入力することさえ困難。
APLで使用する記号はUTF-8に登録されましたが、似た記号が多く入力の難しさは改善されていません。
また表示されていてもそれが文字化けなのか正しいものなのかはAPLをマスターしないとわかりません。
結局はキーボードで入力可能なJ言語が開発されましたが、興味のある方は変態道を突き進んでAPLをマスターして欲しいと思います。

GNU APL

<再帰関数版>

fib_apl.apl
#!/usr/bin/apl --script
∇R←fib N
  →L+(N>1)
  L:R←N ⋄ →0
  R←(fib (N - 2)) + fib (N - 1)
∇

fib ⍎⍕¯1↑⎕ARG

)OFF

⍝ example
⍝   run:
⍝       ./fibonacci.apl -- 20

<行列による漸化式版>
暗号化度さらにUP

fib_apl.apl
#!/usr/bin/apl --script
∇R←fib N
  R←↑0 1↓↑+.×/N/⊂2 2⍴1 1 1 0
∇

fib ⍎⍕¯1↑⎕ARG

)OFF

⍝ example
⍝   run:
⍝       ./fibonacci.apl -- 20

Dyalog・NASR2000

fib←{⍵≤2:1 ⋄ (∇⍵-1)+∇⍵-2}
で定義できる。

Pike

スクリプトのクセに静的型付けな言語です。Cっぽいです。
そのおかげなのかそこそこ速いです。
以前からRubyと同じぐらいの速度を維持しており、むしろRubyが指標としているのではと思わせるほど。

fibonacci.pk
// fibonacci by Pike
int fib(int n)
{
    if (n < 2) {
        return n;
    } else {
        return fib(n-2)+fib(n-1);
    }
}
int main(int argc, array(string)argv)
{
    int n;
    n = (int)argv[1];
    write("%d", fib(n));
    return 0;
}

/*
    example
        run:
            pike fibonacci.pk 39
*/

Icon

ゴール指向評価という「成功」か「失敗」による制御構造を特徴とする言語。
真偽値による評価とどう違うのかと聞かれるとちゃんと答えられませんが、
「if a < b < c」とか気持ち悪いif文が書けます。
他にもジェネレータが強力だったり、リストや連想配列、集合、レコード型などデータ構造も豊富。
手続きそのものを変数にぶちこめる「コ・エクスプレッション」という関数型言語っぽいこともできるそうなのですが、試していません。
そもそも今回のサンプルではそれらの特徴をまったく活かせてません。
面白そうな言語ではありますが。

icontコマンドで実行形式のバイナリにできますが、速度はまったく変わりません。

なお、Wikipediaなどのリンクが古くなっている模様。
http://www2.cs.arizona.edu/icon/
↑が生きています。

アリゾナ大学のサイトで「Past Research Projects」に入っちゃってますが、何かあったのでしょうか?
サイトの更新は2016年現在も続いているようです。

fibonacci.icn
# フィボナッチ数
procedure fibonacci(n)
    if n < 2 then
        return n
    else
        return fibonacci(n - 2) + fibonacci(n - 1)
end

procedure main(args)
    local n
    n := args[1]
    write(fibonacci(n))
end

# example
#    interpreter:
#        icon fibonacci.icn 39
#    translator:
#        icont fibonacci.icn
#        ./fibonacci 39

Qiitaのコードハイライトが対応していません。

Occam

英語も日本語もドキュメントが少ない上に、めちゃくちゃ検索しづらいです。
たぶん「終わった言語」です。
1980年代に次世代のマイクロプロセッサとして並行コンピューティングに特化したアーキテクチャである「トランスピュータ」のために開発された「CSP」をより実用的に拡張した言語です。
そういった出自ゆえ並列処理が得意で、「PAR」とか「SEQ」とかのキーワードで積極的に並列処理と逐次処理を指定できたりするところも面白いです。
並列処理とプロセス間のメッセージやり取り以外は、普通に手続き型の言語です。
コマンドが大文字というところが時代を感じさせます。
ブロックはPython同様のインデント形式ですが、きっちり2文字ずつじゃないと怒られます。

並列処理向けの言語として将来再び注目されるかもしれませんし、されないかもしれません。

KRoc (Occam-π)

ケント大学によって開発されたOccamのコンパイラ。
開発は終わってるっぽいですが、たまにgitが更新されています。
インストーラやビルドツールにPythonが使われていますが、Python3で動きません。
いらっとします。
コマンドライン引数を取得する方法を調べるのに挫折しました。

fibonacci.occ
-- フィボナッチ数 by Occam
#INCLUDE "course.module"

INT REC FUNCTION fib (VAL INT n)
  INT res:
  VALOF
    IF
      n < 2
        res := n
      TRUE
        res := fib (n - 2) + fib (n - 1)
    RESULT res
:

PROC fibonacci (CHAN BYTE out)
  out.int (fib(39), 0, out)
:

-- example
--  compile:
--   occbuild --program fibonacci.occ
--   or
--   kroc fibonacci.occ
--  run
--   ./fibonacci 39

Chapel

アメリカ国防高等研究計画局の高生産性計算機システムプロジェクトです。
スーパーコンピューターのCRAYです。
もうコレだけで強うそうでしょ?
「Chapel」は「Cascade High Productivity Language」の略で、日本語にすると
「多段高生産性言語」だそうです。
厨二ゴコロにどストライクです。

並列計算機「Cascade」のプログラム開発効率を改善するために作られたコンパイラです。
なので前述のOccam同様、並列計算向きの言語です。
もちろんフィボナッチ数のサンプルについてはそこんとこまったく使っていません。

プログラミング効率を上げるためのオブジェクト指向や現代的で見慣れた文法を採用することで、硬派な割にはとっつきやすい感じになっています。

プロジェクト自体は2010年に終了していますが、現在もオープンソースプロジェクトとして開発は絶賛継続中で、CRAY社のホームページで公開されています。

もっと注目されてもいい言語だと思うのですが…。

しかし、フィボナッチ数のサンプルをコンパイルすると3.1MBあります。

fibonacci.chpl
// フィボナッチ数 by Chapel
proc fib(n: int): int {
    if (n < 2) {
        return n;
    } else {
        return fib(n - 2) + fib(n - 1);
    }
}

proc main(args: [] string) {
    var n: int = args[1]:int;
    writeln(fib(n));
}

/*
    example
        compile:
            chpl -o fibonacci fibonacci.chpl
        run:
            ./fibonacci 39
*/

Oz (Mozart)

Ozはマルチパラダイムでネットワーク透過な分散プログラミングができるらしい。よくわからん。
比較的新しい(最初の設計が1991年)言語なので、実用云々よりは、今後のプログラミングの可能性の一つとして見る分には面白いのではないかと。
ただ、ドキュメントは少なく、やっとたどり着いてもほとんどがemacsの説明だったりします。

Mozart2

Ozの高品位な実装がMozart。Mozart2が出ているが、まだAlpha版。とはいうもののそこそこ動くようです。
Ver.1 はLLVMを使っていたようですが、Ver.2はどうなんでしょう?わかんない。
Ver.2 alpha では、ozc -x でコンパイルしても単独で実行できる形にはならないようです。
「ディレクトリ」に依存しないだけかもしれません。(でもエグゼキュートビットは立ってる)
ozc -c と ozc -x でfunctor の書き方が微妙に違うのは私がわかってないせいだと思います。

fibonacci.oz
% フィボナッチ数  by Mozart2(Oz)
functor

import
    System
    Application

prepare
  fun {Fib N}
    if N < 2 then
      N
    else
      {Fib N - 2} + {Fib N - 1}
    end
  end

define
  N in
    [N] = {Application.getArgs plain}
    {System.showInfo {Fib {String.toInt N}}}
    {Application.exit 0}
end

/*
    example
        compile:
            ozc -c fibonacci.oz
        run:
            ozengine fibonacci.ozf 39
*/

fun {Fib N] を fun lazy {Fib N} に書き換えると遅延評価の関数になります。
このサンプルだと遅くなっちゃいました。

Tcl

Tcl はすっごい有能なシェルです。
まず、計算させようとか思ってはいけません。

Tkと合わせればさくっとGUIのアプリケーションが作れます。
しかもLinux と Windows とでほぼ同じソースで。

でも、計算させます。

コメントブロックの書き方が強烈です。(公式な書き方の一つ)

「tcl::mathfunc::」をつけないと再帰呼び出しできないようです。
10分ハマりました。

fibonacci.tcl
# フィボナッチ数 by Tcl
proc tcl::mathfunc::fib {n} {
    if {$n < 2} {
        return $n
    } else {
        return [expr fib([expr {$n - 1}]) + fib([expr {$n - 2}])]
    }
}

set n [lindex $argv 0]
puts [expr fib($n)]

if 0 {
    example
        run:
            tclsh fibonacci.tcl 10
}

おまけ(ネタ枠)

dc

これまた検索しにくい言語?ですが、Linuxでほぼ標準でついてくるRPN(逆ポーランド記法)のコマンドライン計算機です。再帰可能なマクロも書けます。
レジスタのセーブとロードが前置記法になっているのが気に入りませんが…。
dcを使ったフィボナッチ数のサンプルはまだ見たことがありません。
限りなくネタ言語ですし、まぁ、やるやつはいないでしょうけど。
遅いです。

fibonacci.dc
# フィボナッチ数 by dc
sa
[2Q] s.
[d 2 >. 1 - d lfx r 1 - lfx +] sf
la lfx p

# example
#    run:
#        dc -e 30 fibonacci.dc

Bash

大事なもの忘れてました。
Linuxを操作するのにほぼ必須なBash。
再帰関数呼び出しもできるシェル。すっごい有能だと思いませんか?

Tcl「・・・」

でも試すときは引数を少しずつ大きくしていってくださいね。
私は「20」で危険を感じました。

fibonacci.sh
# フィボナッチ数 by bash
#!/bin/bash
fib () {
    if [ $1 -lt 2 ]; then
        echo $1
    else
        echo $(($(fib $(($1-2)))+$(fib $(($1-1)))))
    fi
}

echo $(fib $1)

# example
#    run:
#        ./fibonacci.sh 20

実行速度比較

システム構成
CPU:Intel(R) Core(TM) i7-3930K CPU @ 3.20GHz
メモリ:32GB(速度とか忘れました)
OS:Arch Linux Kernel-4.4.1 SMP x86_64

頭の悪い再帰関数で39番目の値「63,245,986」を求める時間です。
コンパイルオプションは適当に何種類か試して速かったものを採用しました。
関数呼び出しのコストぐらいしかわからないかも。
他のアルゴリズムだと大体瞬殺なので面白くありません。

順位 言語 バージョン 実行時間
1 Fortran (gfortran -O3) 5.3.0 0.146 sec
2 D (gdc -O3) 5.3.0 0.179 sec
3 Nim (-d:release) 0.12.0 0.184 sec
3 Basic (fbc -O3) 1.04 0.184 sec
5 Ada (gnat -O3) 5.3.0 0.194 sec
6 C++ (g++ -O3) 5.3.0 0.252 sec
7 C (gcc -O3) 5.3.0 0.255 sec
8 OCaml (ocamlopt) 4.02.3 0.302 sec
9 Java (Open JDK) 1.8.0 0.303 sec
10 C (clang -O) 3.7.0 0.357 sec
11 Rust (rustc -C opt-level=3) 1.5.0 0.358 sec
12 Swift (swiftc -O) 2.2-dev 0.361 sec
13 Go 1.5.2 0.388 sec
14 Crystal (--release) 0.10.1 0.395 sec
15 Pascal (fpc -O4) 3.0.0 0.405 sec
16 Dart 1.16.0 0.436 sec
17 C# (mono -optimize+) 2.2.2.0 0.442 sec
18 Basic (mono /optimize+) 0.0.0.5943 0.485 sec
19 Scala 2.11.8 0.490 sec
20 D (dmd -O -inline) DMD64 v2.069 0.513 sec
21 JavaScript (SpiderMonkey) 38.1 0.537 sec
22 Haskell (ghc -O2) 7.10.3 0.570 sec
23 julia (-O) 0.4.5 0.711 sec
24 JavaScript (V8) 4.9.170 0.845 sec
25 Lua (luajit) 2.0.4 0.897 sec
26 Chapel 1.13.1 0.959 sec
27 PHP (hhvm) 3.13.1 1.021 sec
28 Groovy 2.4.5 1.287 sec
29 Lisp (sbcl) 1.3.0 1.551 sec
30 OCaml (script) 4.02.3 3.389 sec
31 Erlang (erlc) 19.0.3 4.346 sec
32 Forth (gforth-fast) 0.7.3 4.792 sec
33 Pike 8.0.182 7.205 sec
34 Mind 7.20 7.325 sec
35 PHP 7.0.1 7.735 sec
36 Smalltalk (gst) 3.2.5 8.098 sec
37 Prolog (gplc) 1.4.4 8.305 sec
38 Ruby 2.3.0p0 8.417 sec
39 Lua 5.3.2 10.147 sec
40 Occam (KRoC) 1.6.0 11.510 sec
41 Python 2.7.11 20.680 sec
42 Python 3.5.1 23.375 sec
43 Icon 9.5.1 28.256 sec
44 Oz(Mozart) 2.0.0 aplha 36.134 sec
45 Perl 5.22.1 56.042 sec

この辺までで39番目の値を求めるのは挫折しました。
ここ以下は予選落ちです。
30番目の値「832,040」を求めた結果です。
比較のためPerlでの実行時間も書いています。

順位 言語 バージョン 実行時間
45 Perl 5.22.1 0.843 sec
46 R 3.2.3 2.022 sec
47 Wolfram (Mathematica) 10.3 2.148 sec
48 dc 1.3.95 2.768 sec
49 Tcl 8.6.6 3.262 sec
50 APL (GNU APL) 1.5 6.482 sec
51 Maxima 5.37.2 10.366 sec
52 Perl6 (Rakudo) 2015.12 10.672 sec
53 Snap! (FireFox 45.0a2) 4.0.4 21.1 sec
54 Octave (octave-cli) 4.0.0 35.544 sec

数値処理、数式処理の言語が低い順位になっていますが、そもそもこの辺の言語は、アホみたいなアルゴリズムで速度を求めるものではありませんし、それを補ってあまりある高度なグラフ機能等が含まれています。

あとがき

気が向いたら、メモ化する書き方、黄金比から計算する方法、行列から計算する方法も書くかもしれません。
各言語の特徴を活かした書き方もそのうち…。