# [Challenge] Who wants a challenge?

We already have the ‘code in another language challenge’

This is a bit different. Here you can request challenges.
You just include the language you want it in and the difficulty.
For instance:

Ey, mate. Can you give me a challenge in python. I’m a beginner, so not too hard please?

Get it??

Okay. Start!

Edit: Other people can also give challenges!

3 Likes

3 Likes

Okay. Can you create a function which takes a number `n` and returns a list with the first `n` Fibonacci numbers?

If it’s too hard/easy, tell me as well .

1 Like

Okay it’s 1AM here so I’m gonna sleep on that one.

2 AM with me. No sleep for you, mister. WORK!

1 Like

Ok, ok! On it, sir!

Give me a challenge in js please! A challenge is exactly what I need.

Okay, can you create a function in Javascript that accepts a string and reverses it, maintaining all casing?

For example, passing in: “CoDeCaDeMy” would return “yMeDaCeDoC”.

1 Like

Challenge accepted!!

1 Like

I had it up to the first 100 numbers, then it got deleted after I thought I had it copied, so now it’s gone.

After a while it does get too big… Will you try again?

I might later ;)

“… too big …”

Do you care if he does it with iteration or recursion? It is interesting to try it with large values of `n` using both approaches.

The 100th Fibonacci number is already 218922995834555169026, which is not a problem in Python, but would be in other languages.

I would personally take an iterative approach. You could do a recursive approach, but if you don’t do it with memoization I don’t think you’re gonna get higher than 30 for `n` or something like that. With the memoization, they should be kinda the same, but in practice, the iterative approach will still be faster, because of the overhead of adding something in the call stack.

Done! ```py fiboList = [0,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,2971215073,4807526976,7778742049, 12586269025,20365011074,32951280099,53316291173,86267571272,139583862445,225851433717,365435296162,591286729879, 956722026041,548008755920,2504730781961,4052739537881,6557470319842,10610209857723,17167680177565,27777890035288, 44945570212853,72723460248141,117669030460994,190392490709135,308061521170129,498454011879264,806515533049393, 1304969544928657,2111485077978050,3416454622906707,5527939700884757,8944394323791464,14472334024676221, 23416728348467685,37889062373143906,61305790721611591,99194853094755497,160500643816367088,259695496911122585, 420196140727489673,679891637638612258,1100087778366101931,1779979416004714189,2880067194370816120, 4660046610375530309,7540113804746346429,12200160415121876738,19740274219868223167,31940434634990099905, 51680708854858323072,83621143489848422977,135301852344706746049,218922995834555169026] def fibonacci(n): print fiboList[0:n] ```
It only goes up to the 100th, because it does get too big. I didn't know the way to calculate the numbers in code, so I just Googled these numbers.

That’s just cheating .Here’s one way you could’ve done it:

``````def fiboList(n):
l = [1,1]
while(len(l)<n):
l.append(l[-2] + l[-1])
return l
``````
1 Like

Yeah well not everyone’s a genius like you.

Haha. Do you want a new one, or do you want to give me one or something?

Hi @nicoekkart ,

Here’s a Python challenge for you …

Write a function that returns a tuple of tuples that specifies solutions for the Tower of Hanoi puzzle.

``````def hanoi_function(num, ori, des, aux):
``````

`num` is the number of disks
`ori` is a name for the starting peg.
`des` is the destination peg.
`aux` is the auxiliary peg.

If the function is called with …

``````print(hanoi_function(3, "A", "B", "C"))
``````

… it would print …

`(('A', 'B'), ('A', 'C'), ('B', 'C'), ('A', 'B'), ('C', 'A'), ('C', 'B'), ('A', 'B'))`

Note that the returned object is a tuple of tuples. Each of the internal tuples is an ordered pair that specifies a move. The first item in the pair is the peg from which a disk should be taken, and the second item is the peg where the disk should go.

We’ll allow you the amount of time it takes to play the game with `64` disks by hand to solve the puzzle.

Quickly worked up a version:

``````from functools import lru_cache

@lru_cache(maxsize=None)
def hanoi(n, a, b, c):
if n==0:
return ((),)
return tuple(
filter(
bool,
hanoi(n-1, a, c, b) +
((a, b),) +
hanoi(n-1, c, b, a)
)
)
``````

Pretty easy if you know DP .

2 Likes