Fibonacci


fibs :: [Int]
fibs = 0 : 1 : [ a + b | (a, b) <- zip fibs (tail fibs)]
Fibonacci

zipWith

fun fac 0 = 1
  | fac n = n * fac(n-1)

>>2
winzip?

fibs = 0 : 1 : zipWith (+) fibs (tail fibs) ???

btw zipWith is a weird name for what's esentially a map. Yes, I know it zips, uncurries, and maps, but well... it's a map, at least to my lisp mind

fib[0]:0; fib[1]:1; fib[n]:=fib[n-1]+fib[n-2];

pwnd by maxima

I have written one in my time for my home page, fully optimized, unlike yours:


<?php
function calculateFibonacciNumber( $Number ) {
    if($Number == 1) {
        return $Number;
    }
#    else {
        var $Result;
#        $Result = calculateFibonacciNumber($Number-1)*calculateFibonacciNumber($Number-2);
#        return ($Result-1)+($Result-2);
#        $Result = calculateFibonacciNumber($Number-1)+calculateFibonacciNumber($Number-2);
#    }

    if($Number == 0) { # Thanks, Alex
        return $Number;
    }
   
    $Result=calculateFibonacciNumber($Number-1);
   
    if($Number == 2) {
        return 1;
    }
    if($Number == 3) {
        return 2;
    }
    if($Number == 3) {
        return 2;
    }
   
    $Result=$Result+calculateFibonacciNumber($Number-2);
   
    return $Result;
}
>

>>7

I fucking lol'd hard.

>>7
enterprise crap? in MY PHP?

>>7
You fool! You forgot validating $Number now ur site is vulnerable to XSS attacks u gonna get hacked. Heres some fix for it.

function calculateFibonacciNumber( $Number = "" ) {
    //modified by Anonymous
    if(!empty($Number)){
        //do nothing
    }else{
        echo "DEBUG: \"\$Number\" is empty";
        return true; //true if empty, else Fibonacci
    }
    if(!((trim("".$Number.""))==($Number))){
        $Number = $Number + 0; //web code snippet from www.snippetsrus.com
    }
    $Number = (int) $Number;

The rest is the same.

You guys know that Fib can be calculated in O(C)?

>>11
But mine is faster I'm using echo instead of printf

>>11

Yes, using Binet's formula. Or a lookup table.

: fib ( n -- n ) 5 sqrt tuck dup 1 swap - swap 1+ pick ^ swap pick ^ - -rot 2^ * / ;

>>14
One-liners don't go well with Forth^WFactor.

If you want to play unreadable golf, use Perl.

swap swap swap

Apparently this might get added to Factor 0.90: http://useless-factor.blogspot.com/2007/07/thats-dirtiest-macro-ive-ever-seen.html

So something like "tuck dup" can be rewritten as "xy-yxx". It's a lot easier to track what you're doing when you have long chains of stack manipulation.

"xy-yxyy"
fix'd

Goes to show that stack shuffling sucks.

>>17
reminds me of car/cdr/caar/cadr/cddr and some of the more exotic lisp macros

thread dup sage

Factor is halfway between Lisp and Brainfuck

>>15
perl?
sub fib{my$n=pop,$f=5**.5;return+((1+$f)**$n-(1-$f)**$n)/($f*2**$n)}
: fib ( n -- n ) 1 5 sqrt 3dup 3dup + swap ^ -roll - swap ^ -roll rot 2^ * * /;
look at that, it's only 10 characters shorter than it is in factor!

>>22
oops.
s/10/11/

>>22,23
Potentially same people.

>>22
The Perl version is more readable too. D:

Although, to be fair, the Perl version isn't using Binet's formula, which the Factor version is: http://mathworld.wolfram.com/BinetsFibonacciNumberFormula.html

>>26
both versions in >>22 use it.

>>22
the factor version is actually shorter if you count tokens instead of characters.

>>27
Whoops. I glanced at it and saw no sqrt and something that looked vaguely recursive.

What's with the + in "return+"?

lol wut, the simple haskell version is shorter than both perl and factor, and way more readable than both. actually it's not a haskell hack or anything, just the definition of the function, and i'm betting it looks the same in pretty much every language that's not retarded.
f n = ((1 + sqrt 5) ^^ n - (1 - sqrt 5) ^^ n) / ((2 ^^ n) * sqrt 5)
sub fib{my$n=pop,$f=5**.5;return+((1+$f)**$n-(1-$f)**$n)/($f*2**$n)}
and if you do the perl trick of skipping whitespace, it gets shorter
f n=((1+sqrt 5)^^n-(1-sqrt 5)^^n)/((2^^n)*sqrt 5)

scheme:

(define (f n) (/ (- (expt (+ 1 (sqrt 5)) n) (expt (- 1 (sqrt 5)) n)) (sqrt 5) (expt 2 n)))

and when you skip the whitespace...
(define(f n)(/(-(expt(+ 1(sqrt 5))n)(expt(- 1(sqrt 5))n))(sqrt 5)(expt 2 n)))
which is shorter than factor (and way way way more readable, unless you happen to think dup, swap, rot, tuck and nip are better than lotsa parenthesis)
btw, that shuffling macro seems interesting, I for instance can hardly remember what the functions do.

>>29
http://perldoc.perl.org/perlop.html#Named-Unary-Operators-operator%2c-named-unary

and way way way more readable, unless you happen to think dup, swap, rot, tuck and nip are better than lotsa parenthesis
you'd be surprised how many people do.

also, >>30-31 should count every pair of parentheses as a token.

if you're counting characters, that's just stupid. especially when comparing different languages.

>>32
Whoa... those named unary operators seem like evil cruft. Why not just use parens properly? Did I miss something?

>>32
counting tokens is equally unuseful IMHO, because there is quite a difference in reading shuffling words and a single parenthesis. I think that the versions I proposed are superior (if we don't skip whitespace), because it's a mathematical function and they express it in a mathematical, succint way.
Yes, I know many people prefer dup swap rot tuck to ))))), but I still recon those versions I proposed are more readable.

>>33
because it's perl and '+' is one character shorter than '()'.

: fib ( n -- n ) 5 sqrt ab-babb 1 swap - swap 1+ abc-abca ^ abc-acba ^ - abc-cab 2^ * / ;

APL
fib ← {⍬⍴⌽∘(+\)⍣⍵,0 1}   
(Bah. http://www.dyalog.dk/dfnsdws/n_fibonacci.htm)
         

>>37
Now I know what Perl was modelled after.

>>37
you should use binet's formula instead.
fib ← (0.5×1+1 ¯1×5*0.5)∘{(-⌿⍺∘.*⍵)÷-/⍺}

From Owl's (Forth knock-off) site:

["\n"]c,"Fibonacci numbers\n"1.c@1 1[%0>][%.c@%2'2'+]!"Done!\n"m

Let's see in detail what happens:
- the ["\n"]c, group stores (,) in c a function whose only scope is emitting a new line ("\n")
- after the title (which is printed), the loop begins (in forth it would be a BEGIN WHILE REPEAT cycle)
- the two functions that manage this cycle are [%0>] (the control syntax sounds like "until the number on top of stack is positive") and [%.c@%2'2'+] (this is the actual algorithm for calculating Fibonacci numbers)
- the cycle is marked by the ! command
- the c@ sequence executes the function in c (new line)
- the 2' sequence is a ROT (namely a 2 ROLL in forth style)
- the symbol % is the DUP command
- the cycle stops when the number on TOS is negative (see the control function [%0>])

This program (actually a line) works on all systems that resolve an integer overflow as a negative number (e.g., for what about 32bit machines, my eMac G4 performs 2147483647 + 1 = -2147483648, which is a perfectly legal number).

The output (on my emac G4 1.42 GHertz) is:

Fibonacci numbers
1
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181
6765
10946
17711
28657
46368
75025
121393
196418
317811
514229
832040
1346269
2178309
3524578
5702887
9227465
14930352
24157817
39088169
63245986
102334155
165580141
267914296
433494437
701408733
1134903170
1836311903
Done!

>>40
what the FUCK

That's Owl.
You've probably heard of Brainf**k.
Its author was inspired by a toy Forth called FALSE.
FALSE also inspired someone to with a similar toy Forth called Owl. It turns out there are a lot of people who get their kicks designing weird languages (Befunge, Bloop, etc.), and they play off each other's designs. There are several forks from FALSE, and some interesting apps written in FALSE as well.

BTW, the original FALSE was 1 page of Amiga assembler.

>>40
I'll take APL instead, thanks

Some APL notes:
-It comes from math. The weird Greek symbols are favored by mathematicians writing formulas.
-Its author later wrote J, and APL users mostly switched to J.
-APL specializes in vectors: sorting, searching, merging, etc. When you step outside that problem domain, APL can be more trouble than help.
-Morgan Stanley wrote the A+ implementation of APL and offers it free. Vector math is useful in financial computing.
-The IOCCC 1989-robison program is a pico APL interpreter. No loops, but it does have functions and "indirection".
-Most full implementations have an interactive environment supporting individual function changes and fast development.
-dmoz has a category: http://dmoz.org/Computers/Programming/Languages/APL

http://www.jsoftware.com/jwiki/Essays/Fibonacci_Sequence

The concept of divide   and conquer in   general It is   as they say   goto considered harmful   my max gs   print nDEATH n   print The word   was word n.

6f 6d 53 70   65 63 3d   43 3a 5c   43 55 44   41 5f 49.

C C has all the ones that   picked it up   and write the   damn thing in   C that you   type in to   debug and you   put Do Nothing   I think the   compilers are removing   support uh just!

Lain.