[PYTHON] Darstellung von Fibonacci-Sequenzen mit Lambda-Ausdrücken in verschiedenen Sprachen

Ich hatte die Möglichkeit, eine Fibonacci-Sequenz mit Lambda-Ausdrücken in verschiedenen Sprachen auszudrücken.

Javascript-Ausgabe

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

Python Edition

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

Ruby Edition

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

Seit Ruby 1.9 hat die Anzahl der Möglichkeiten zum Schreiben von Lambda-Funktionen zugenommen, sodass Sie auch wie folgt schreiben können (danke @ 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

c ++ Edition

Quellcode

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

Ausführungsverfahren

python

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

vim edition

Auf vim 8.0 aktualisiert

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 

Quellcode

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)

Ausführungsverfahren

python

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

Impressionen

Sogar eine Art, Lambda-Stil zu schreiben, ist, dass jede Sprache ihre eigene Persönlichkeit hat. Python und Ruby waren persönlich intuitiv. Ich habe es geschafft, Haskell, Javascript und C ++ zu bekommen, aber ich war mit der Grammatik nicht ganz vertraut. vim wurde für Menschen am Arbeitsplatz empfohlen und ich habe es geschrieben. Ich hatte die schwerste Zeit, aber ich war sehr beeindruckt, als ich es schaffte.

Wenn Sie andere einzigartige Lambda-Ausdrücke haben, lassen Sie es mich bitte wissen :)