weppos/44.go

citaret · 2019-07-30T03:32:37Z

My version:

func fibonacci() func() int {
    a, b := 1, 0
    return func() int {
        a, b = b, a+b
        return a
    }
}

banothurameshnaik · 2019-09-20T05:02:37Z

package main

import "fmt"

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func(int) int {
	first := 0
	second := 1
	return func(i int) int {
		if i == 0 || i == 1 {
			return i
		}
		sum := first + second
		first = second
		second = sum
		return sum
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f(i))
	}
}

ptflp · 2019-12-13T14:06:48Z

My version:

func fibonacci() func() int {
    a, b := 1, 0
    return func() int {
        a, b = b, a+b
        return a
    }
}

it's not your solution, this solution belongs to @stvr in 2012

dougahmann · 2020-02-02T22:06:23Z

func fibonacci() func() int {
	previous := 0
	last := 0
	index := 0
	
	return func() int {
		var result int
		if index == 1 {
			result = 1
		} else {
			result = last + previous	
		}
		
		previous = last;
		last = result;
		index++
		
		return int(result)
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

This is what I came up, before searching for other's solutions. Mine doesn't modify main(), which I believe was part of the spirit of the exercise. Otherwise, very close to banothurameshnaik's solution.

In any case, I find this more readable than the first example as someone new to Go (but with 30+ years programming experience). Is the bunching of multiple assignments on a line (e.g. a, b := 1, 0) really considered "best practice"? Seems like it's being clever at the expense of readability. Probably biased by my experience with other languages. Maybe my opinion will change over time. Other than slightly less typing and fewer lines, what else would be the advantage of using the shorter notation?

Thanks in advance for any opinions.

Thargelion · 2020-03-26T22:15:16Z

This starts with zero and does not modifies main()

package main

import "fmt"

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
	a, b := 0, 1
	return func() int {
		result := a // Store the result value before translations
		c := a + b // Fibonacci
		a = b // Translation
		b = c // Translation
		return result
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

anuragguptagithub · 2020-07-03T06:10:14Z


import "fmt"

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
    a: = 0
    b: = 1
    sum: = a + b
    return func() int {
        if a == 0 {
            a = b
            return 0
        }
        a = b
        b = sum
        sum = a + b
        return a
    }
}

func main() {
    f: = fibonacci()
    for i: = 0;i < 10;i++{
        fmt.Println(f())
    }
}```

anuragguptagithub · 2020-07-03T06:26:13Z


import "fmt"

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
	a, b := 1, 0
	return func() int {
		a, b = b, a+b // two assignment happens parallely, but if you enforce it sequentially, it won't work
		return a
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

Wuitar · 2020-07-14T05:29:30Z

use slice

package main

import "fmt"

func fibonacci() func() int {
	var i []int
	return func() int {
		if len(i) == 0 {
			i = append(i, 0)
		} else if len(i) == 1 {
			i = append(i, 1)
		} else {
			i = append(i, i[len(i)-2]+i[len(i)-1])
		}
		return i[len(i)-1]
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

is3ka1 · 2021-02-17T05:46:56Z

Using defer

package main

import "fmt"

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
	cum1 := 0
	cum2 := 1
	return func() int {
		defer func() { cum1, cum2 = cum2, cum1+cum2 }()
		return cum1
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

drewkiimon · 2021-03-22T22:49:10Z

I like your answer! I can do fib numbers but a bit tricky with this problem with closures. Thank you for your answer!

Dimedrolity · 2022-02-09T15:14:48Z

one letter variables is evil (except loop var)

traditional

func fibonacci() func() int {
	current := 0
	next := 1

	return func() int {
		current, next = next, current+next

		return current
	}
}

with defer

func fibonacci() func() int {
	current := 1
	next := 1

	return func() int {
		defer func() {
			current, next = next, current+next
		}()

		return current
	}
}

Rexoen · 2022-08-07T10:21:18Z

package main

import "fmt"

func fibonacci() func() []int {
	arr := make([]int,0)
	return func() []int {
		switch len(arr){
			case 0:
				arr = append(arr,0)
			case 1:
				arr = append(arr,1)
			default:
				arr = append(arr,arr[len(arr)-1]+ arr[len(arr)-2])
			
		}
		return arr
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

PradeepLR01 · 2022-09-08T15:26:39Z

Here is my solution -

package main

import "fmt"

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
	x, y := 0, 1
	return func() int{
		x++
		y++
		return (x-1)+(y-2)
	}

}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

kash74 · 2022-09-14T09:54:21Z

Not as elegant but doing the job:

package main

import "fmt"

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
	i := -1
	f1 := 0
	f2 := 1
	return func() int {
		switch i+=1; i {
		case 0:
			return 0	
		case 1:
			return 1
		default:
			f := f1 + f2
			f1 = f2
			f2 = f
			return f
		}
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

netmanyys · 2022-10-03T01:04:17Z

We can omit the variable f with

package main

import "fmt"

// fibonacci is a function that returns
// a function that returns an int.

func fibonacci() func() int {
	f1, f2 := 0, 1
	return func() int {
		f1, f2 = f2, f1+f2
		return f1
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

vojtaripa · 2022-11-02T17:08:05Z

similar to other solutions using if statements
Hope it helps someone out there

package main

import "fmt"

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func(int) int {
	
	prev2 := 0
	prev1 := 1
	
	return func(x int ) int{
		
		sum:=0
		
		//SKIPPING FIRST 2 ITTERATION
		if x == 0{
			return 0
		}else if x == 1{
			return 1
		}else{
			//Staring at 2 value should still be 1
			sum = prev1 + prev2
		}
	
		//THEN MAKE PREVIOUS VALUES CURRENT FOR NEXT ITTERATION
		prev2 = prev1 
		prev1 = sum 
		
		
		//RETURN THE RESULT
		return fib
	}
	
}

func main() {
	//Assigning a function fibonacci
	f := fibonacci()
	
	//now looping through and passing i each time
	for i := 0; i < 10; i++ {
		fmt.Println(i,"->",f(i))
	}
}

krapie · 2022-12-07T10:35:43Z

package main

import "fmt"

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
	f1, f2 := 0, 1
	
	return func() int {
		// f is previous fibonacci number
		// f() closure actually returns
		// previous fibonacci number
		f := f1
		f1, f2 = f2, f1+f2
		
		return f
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

u-onder · 2022-12-29T13:52:57Z

With defer

func fibonacci() func() int {
	var v0, v1 int = 0,1
	advance := func () {
		v0, v1 = v1, v0+v1
	}
	return func() int {
		defer advance()
		return v0
	}
}

alkstsgv · 2023-06-28T11:48:29Z

package main

import "fmt"

func fibonacci() func() uint64 {
	
	a := uint64(0)
	b := uint64(0)
	c := uint64(a + b)

	return func() uint64 {
		if c-a > c-b {
			c = c + (c - a)
			a = c - b
			return c
		} else if c-a < c-b {
			c = c + (c - b)
			b = c - a
			return c
		} else if c == c {
			a += 0
			b += 1
			c += 1
			return c
		}
		return c
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 1000; i++ {
		fmt.Println(f())
	}
}

Max95Cohen · 2023-09-25T16:43:04Z

package main

import "fmt"

func fibonacci() func() int {
	f := [10]int{0, 1}
	i := 0

	return func() int {
		last := i
		i++

		if last == 0 || last == 1 {
			return f[last]
		}

		f[last] = f[last-1] + f[last-2]

		return f[last]
	}
}

func main() {
	f := fibonacci()

	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

json-bateman · 2023-10-08T15:13:00Z

package main

import "fmt"

func fibonacci() func() int {
	fib, temp, next := 0, 0, 1
	
	return func() int {
		fib = temp
		temp = next
		next = fib + temp
		return fib
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

KJ1010G · 2024-03-04T10:38:23Z

package main

import "fmt"

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
	num := 0
	nextNum := 1
	advance := func () {
		temp := nextNum
		nextNum = num + nextNum
		num = temp
	}
	return func () int {
		defer advance()
		return num
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

forbidden-game · 2024-03-21T14:32:37Z

package main

import "fmt"

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
f1 := 0
f2 := 1
reFunc := func() int {
f := f1
f1 = f2
f2 = f + f1
return f
}
return reFunc
}

func main() {
f := fibonacci()
for i := 0; i < 100; i++ {
fmt.Println(f())
}
}

liminspace · 2024-03-25T23:03:32Z

package main

import "fmt"

func fibonacci() func() int {
	a, b := 1, 0
	return func() int {
		a, b = b, a + b
		return a
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

pabloxio · 2024-06-29T07:18:29Z

hehe basically we all disagree about variables names 😄

package main

import "fmt"

// fibonacci is a fucntion that returns
// a function that returns an int.
func fibonacci() func() int {
	current, next := 0, 1
	return func() int {
		fib := current
		current, next = next, current+next

		return fib
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

P.S.: The solution with the defer statement is pure gold 🥇

pavel-kalmykov · 2024-06-29T21:17:37Z

P.S.: The solution with the defer statement is pure gold 🥇

Could you please elaborate on what's so special about using defer here? I do not see any improvement over not using it.

pabloxio · 2024-06-29T22:04:19Z

Could you please elaborate on what's so special about using defer here? I do not see any improvement over not using it.

two things:

When I was solving the exercise, using defer never crossed my mind, so when I saw that solution it was an ahá moment 🤯
I saw it as a readability improvement for sure, the combination between Function closures (link) and the defer statement, imho it's way simpler to read:

func fibonacci() func() int {
	current, next := 0, 1

	return func() int {
		defer func() {
			current, next = next, current+next
		}()

		return current
	}
}

pavel-kalmykov · 2024-07-29T19:13:12Z

@pabloxio, I think I understand now how it works (the trick is that values will be updated after current is returned), but I do not really see any improvement between the defer approach and something like this:

func fibonacci() func() int {
	curr, next := 1, 0
	return func() int {
		curr, next = next, curr + next
		return curr
	}
}

Am I missing something?

filipcvejic · 2025-04-29T20:49:38Z

package main

import "fmt"

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
	a, b := 0, 1
	return func() int {
		result := a
		a, b = b, a + b
		return result
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

	package main

	import "fmt"

	// fibonacci is a function that returns
	// a function that returns an int.
	func fibonacci() func() int {
	f2, f1 := 0, 1
	return func() int {
	f := f2
	f2, f1 = f1, f+f1

	return f
	}
	}

	func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
	fmt.Println(f())
	}
	}

weppos/44.go

citaret commented Jul 30, 2019

Uh oh!

banothurameshnaik commented Sep 20, 2019

Uh oh!

ptflp commented Dec 13, 2019

Uh oh!

dougahmann commented Feb 2, 2020 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Thargelion commented Mar 26, 2020 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

anuragguptagithub commented Jul 3, 2020

Uh oh!

anuragguptagithub commented Jul 3, 2020 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Wuitar commented Jul 14, 2020

Uh oh!

is3ka1 commented Feb 17, 2021

Uh oh!

drewkiimon commented Mar 22, 2021

Uh oh!

Dimedrolity commented Feb 9, 2022

one letter variables is evil (except loop var)

Uh oh!

Rexoen commented Aug 7, 2022

Uh oh!

PradeepLR01 commented Sep 8, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

kash74 commented Sep 14, 2022

Uh oh!

netmanyys commented Oct 3, 2022

Uh oh!

vojtaripa commented Nov 2, 2022

Uh oh!

krapie commented Dec 7, 2022

Uh oh!

u-onder commented Dec 29, 2022

Uh oh!

alkstsgv commented Jun 28, 2023

Uh oh!

Max95Cohen commented Sep 25, 2023

Uh oh!

json-bateman commented Oct 8, 2023 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

KJ1010G commented Mar 4, 2024

Uh oh!

forbidden-game commented Mar 21, 2024

Uh oh!

liminspace commented Mar 25, 2024

Uh oh!

pabloxio commented Jun 29, 2024

Uh oh!

pavel-kalmykov commented Jun 29, 2024

Uh oh!

pabloxio commented Jun 29, 2024

Uh oh!

pavel-kalmykov commented Jul 29, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

filipcvejic commented Apr 29, 2025

Uh oh!

dougahmann commented Feb 2, 2020 •

edited

Loading

Thargelion commented Mar 26, 2020 •

edited

Loading

anuragguptagithub commented Jul 3, 2020 •

edited

Loading

PradeepLR01 commented Sep 8, 2022 •

edited

Loading

json-bateman commented Oct 8, 2023 •

edited

Loading

pavel-kalmykov commented Jul 29, 2024 •

edited

Loading