FIBONACCI FIB PRINT

FIBONACCI FIB PRRINT

Write a program that prints out a list of fibonacci numbers in a language of your choice.


/*        I'm using C, you LISPing cretins.         /
/  Remember to use your hot, stripping [coed] tags */

#include <stdio.h>

fibonacci (int fibs)
{
    int count, big = 0, small = 1;
    for (count = 0; count <= fibs; count++)
    {
        printf("\n#%2d - %10d", count, big);
        big = big + small;
        small = big - small;
    }
}

main()
{
    int x;
    printf("Enter the highest fib that you want to see: ");
    scanf("%i", &x);
    fibonacci (x);
}
Your move.

learn to write valid C if you're going to be an EXPERT C PROGRAMMER

>>1
Won't work once you reach 0x7FFFFFFF, which should be at fib(46) or so.

Here's a REAL and PROPER/NON-HACKY solution:

(defun memoize (fn)
  (declare (optimize (speed 3) (safety 0) (debug 0)))
  (let ((cache (make-hash-table :test #'equal)))
    #'(lambda (&rest args)
        (multiple-value-bind (val win) (gethash args cache)
          (if win
              val
              (setf (gethash args cache)
                    (apply fn args)))))))

(defun fibs (n)
  (case n
    (0 0)
    (1 1)
    (2 1)
    (t (+ (fibs (- n 2)) (fibs (- n 1))))))

(setf (symbol-function 'fibs) (memoize #'fibs))

;; reads a number and prints 0-number fibs
(let ((*read-eval*) nil)
  (dotimes (i (read)) (print (fibs i))))

;;; Speed is decent, but memory usage is wasteful. A cutomized memoization function using arrays is possible, and here's a toy example of it:

(defun memoize-special (fn)
  (declare (optimize (speed 3) (safety 0) (debug 0))) 
  (let ((cache (make-array 1000 :adjustable t :initial-element nil)))
    #'(lambda (n)
        (let ((val (aref cache n)))
          (if val val
              (setf (aref cache n)
                    (funcall fn n)))))))


;;; Here's a zomgoptimized version for the ctards:
(defun print-fibs-to-n (n)
  (declare (optimize (speed 3) (safety 0) (debug 0)))
  (do
   ((previous 1 current)
    (current 0 (+ previous current))
    (k 0 (1+ k)))
   ((= k n) current)   
    (print current)))

(let ((*read-eval*) nil)
  (print-fibs-to-n (read)))

Oh fuck, I keep forgetting the damn code tags:

(defun memoize (fn)
  (declare (optimize (speed 3) (safety 0) (debug 0)))
  (let ((cache (make-hash-table :test #'equal)))
    #'(lambda (&rest args)
        (multiple-value-bind (val win) (gethash args cache)
          (if win
              val
              (setf (gethash args cache)
                    (apply fn args)))))))

(defun fibs (n)
  (case n
    (0 0)
    (1 1)
    (2 1)
    (t (+ (fibs (- n 2)) (fibs (- n 1))))))

(setf (symbol-function 'fibs) (memoize #'fibs))

;; reads a number and prints 0-number fibs
(let ((*read-eval*) nil)
  (dotimes (i (read)) (print (fibs i))))

;;; Speed is decent, but memory usage is wasteful. A cutomized memoization function using arrays is possible, and here's a toy example of it:

(defun memoize-special (fn)
  (declare (optimize (speed 3) (safety 0) (debug 0))) 
  (let ((cache (make-array 1000 :adjustable t :initial-element nil)))
    #'(lambda (n)
        (let ((val (aref cache n)))
          (if val val
              (setf (aref cache n)
                    (funcall fn n)))))))


;;; Here's a zomgoptimized version for the ctards:
(defun print-fibs-to-n (n)
  (declare (optimize (speed 3) (safety 0) (debug 0)))
  (do
   ((previous 1 current)
    (current 0 (+ previous current))
    (k 0 (1+ k)))
   ((= k n) current)   
    (print current)))

(let ((*read-eval*) nil)
  (print-fibs-to-n (read)))

>>2

I'm pretty sure I just compiled this shit at least 10 different times in the latest version of GCC. IHBT.

>>3-4

Yeah it's got integer wrap around, big whoop wanna fight about it?

>>5
Just because gcc lets you compile it doesn't mean it's valid, fucklip.

>>6
As in, you know, conforming to that funny little thing called The C Standard.  And gcc will compile code that is neither valid C89 nor C99 as long as you don't use --pedantic.

>>7
Enjoy your GNU C

def fib(n):
    a, b = 0, 1
    while 1:
        yield a
        a, b = b, a + b

a = fib()
for i in range(10):
    print a.next()

>>6-7

Just compiled it with the pedantic flag set, no errors. If there you'd like to point out an error in my code that the compiler missed, or if I do not conform to some standard, feel free to correct me, but otherwise

back to /b/, please.

>>9
my bad. remove the args


def fib():
    a, b = 0, 1
    while 1:
        yield a
        a, b = b, a + b

a = fib()
for i in range(10):
    print a.next()

Lua:
for i = 1, 100 do print(math.floor(((1 + 5 ^.5) / 2)^i / (5^.5) + .5)) end

>>10
-c99 -pedantic -Wall -Werror or -ansi -pedantic -Wall -Werror are the only acceptable options. I didn't test your code, though.

>>13
warning: return type defaults to "int"

I guess you're right on that. To be fair, they use functions without return types all the time in K&R 2nd Edition, but I digress.


/*        I'm using C, you LISPing cretins.         /
/  Remember to use your hot, stripping [coed] tags */

#include <stdio.h>

void fibonacci (int fibs)
{
    int count, big = 0, small = 1;
    for (count = 0; count <= fibs; count++)
    {
        printf("\n#%2d - %10d", count, big);
        big = big + small;
        small = big - small;
    }
}

int main()
{
    int x;
    printf("Enter the highest fib that you want to see: ");
    scanf("%i", &x);
    fibonacci (x);
   
    return 0;
}Better?


void print_fibs (int count) {
    int a = 1, b = 1;
    while (count--) {
        printf("%d\n",a);
        b += a;
        a = b - a;
    }
}

>>14
That book is over 20 years old. Things change. In this case it's definitely for the better.

LOL LISTS IN C LOL


import Data.List(foldl')
import Data.Bits(testBit,bitSize)
 
fib :: Int -> Integer
fib n = snd . foldl' fib' (1, 0) $ dropWhile not [testBit n k | k <- let s = bitSize n in [s-1,s-2..0]]

fib' :: (Num t) => (t,t) -> Bool -> (t, t)
fib' (f, g) p
 | p = (f*(f+2*g),f*f+g*g)
 | True = (f*f+g*g, g*(2*f-g))

>>17
At least the C code is readable.

Here's a bash snippet:

dd if=/dev/fibs bs=16b count=$COUNT

/dev/fibs is actually a named pipe to some wankery fibs implementation of your choice with the obvious constraints (one being that it is fixed output padded to 16 characters in case you missed that part.)

>>1
Gayest comment style ever.

>>16
Exactly. Just like math should finally accept that in some cases 99.9% == 100%.

>>21
First, they would need to accept the legitimacy of the == operator, and then IHBTBYA

I Have Been Tantalized By Young Anus

>>20

Are you implying that C style comments are gay?

>>24
No, this is gay:


/* I am a    /
/ big anus,  /
/ talk&feel */

Less gay:

  /* I am a    /
 / big anus,  /
/ talk&feel */

Not gay at all:


/* I am a
big anus,
talk&feel */

OR


/*
  I am a
  big anus,
  talk&feel
*/

import System

fibs = 0: scanl (+) 1 fibs

main = map print . fibs . head =<< getArgs

>>25

I'm actually kind of liking the "less gay" style.


  /* HAX  /
 /  MY   /
/ ANUS */

>>26
You mean print . (fibs !!) . head, surely.

>>25

/*********************
 * What about these? *
 *********************/

I think I might modify cpp to allow ``faggot commenting''

>>30

Please don't do ``that.''


/*
 *   I am a
 *   big anus
 *   talk&feel
 */

The /prog/-indentation style for comments;


              /*
       I am a
     big anus
    talk&feel
 */

>>33
Kinda reminds me of http://dis.4chan.org/read/prog/1243170860/53

>>28
OP said the program should print a list of fibonacci numbers, so no, I meant what I wrote.

>>28
On second thought, what I meant was mapM_ print . fibs . head .

>>36
But fibs is not a function, it is a list, so how can you compose it with other functions?

Perhaps mapM_ print . (`take` fibs) . read . head =<< getArgs then. Or mapM_ print . (`take` fibs) =<< readIO . head =<< getArgs.

>>37
Fuck, that's what I get for not testing code before posting it on /prog/. Yes, kind sir, you're absolutely right, what should have meant was mapM_ print . (`take` fibs) . read . head =<< getArgs. Thank you for pointing it out.

42 Name: Anonymous 2013-06-18 18:27