[RUBY] Représentation de séquences de Fibonacci à l'aide d'expressions lambda dans différentes langues

J'ai eu la chance d'exprimer une séquence de Fibonacci en utilisant des expressions lambda dans différentes langues.

édition javascript

fib.js

var fib = function(v){
  return(function(f,m){
    return f(f,m)
  }(function(r,n){
    return n < 2 ? n : r(r,n-1)+r(r,n-2)
  },v)
)}

édition python

python

$ python
>>> fib = lambda n: n if n < 2 else fib(n-1) + fib(n-2)
>>> fib(0)
0
>>> fib(1)
1
>>> fib(2)
1
>>> fib(6)
8

édition rubis

python

$ irb
irb(main):001:0> f = lambda { |n| n < 2 ? n : f.call(n-1) + f.call(n-2) }
$ irb(main):002:0> f.call(0)
0
$ irb(main):003:0> f.call(1)
1
$ irb(main):004:0> f.call(2)
1
$ irb(main):005:0> f.call(6)
8

Depuis ruby 1.9, la façon d'écrire des fonctions lambda a augmenté, vous pouvez donc également écrire comme suit (merci @ kbaba1001)

[1] pry(main)> f = ->(n) { n < 2 ? n : f[n-1] + f[n-2] }
=> #<Proc:0x007fb5ac26fe58@(pry):1 (lambda)>
[2] pry(main)> f[0]
=> 0
[3] pry(main)> f[1]
=> 1
[4] pry(main)> f[2]
=> 1
[5] pry(main)> f[3]
=> 2
[6] pry(main)> f[6]
=> 8

haskell

python

$ ghci
Prelude> let fib = 0:1:zipWith (+) fib (tail fib)
Prelude> fib !! 0
0
Prelude> fib !! 1
1
Prelude> fib !! 2
1
Prelude> fib !! 6
8

édition c ++

Code source

fib.cc

#include <iostream>
#include <functional>
using namespace std;

int main(int argc, char const *argv[])
{
  std::function<int(int)> fib = [&fib](constintn)  {
    return n < 2 ? n : fib(n - 1) + fib(n - 2);
  };

  cout << fib(0) << endl;
  cout << fib(1) << endl;
  cout << fib(6) << endl;

  return 0;
}

Procédure d'exécution

python

$ g++ -std=c++11 fib.cc 
$ ./a.out 
1
1
8

édition vim

Mis à jour vers vim 8.0

python

$ apt-get install software-properties-common # if not found add-apt-repository command
$ sudo add-apt-repository ppa:jonathon/vim
$ sudo apt-get update
$ sudo apt-get install vim
$ vim --version
$ sudo add-apt-repository -remove ppa:jonathon/vim # delete PPA if needed 

Code source

fib.vim

function! Main()
  let Y = {f -> (({x -> f ({y -> x(x)(y)})})({x -> f ({y -> x(x)(y)})}))}
  let Fib = {f -> {n -> (n < 2 ? n : f(n-1) + f(n-2))}}
  echo Y(Fib)(0)
  echo Y(Fib)(1)
  echo Y(Fib)(2)
  echo Y(Fib)(6)

Procédure d'exécution

python

$ vim
:source fib.vim
:call Main()

Impressions

Même une façon d'écrire le style lambda est que chaque langue a sa propre personnalité. Personnellement, python et ruby étaient intuitifs. J'ai réussi à obtenir Haskell, javascript et c ++, mais je n'étais pas complètement familier avec la grammaire. vim a été recommandé pour les personnes sur le lieu de travail et je l'ai écrit. J'ai eu les moments les plus difficiles, mais j'ai été très impressionné quand j'ai pu le faire.

Si vous avez d'autres expressions lambda uniques, faites-le moi savoir :)