FUCKING DYNAMIC PROGRAMMING

How do I learn to do this shit?

I'm going to fail introduction to algorithms and be the disgrace of MIT...

PROTIP, it's the same as recursive programming but you reuse the old values.

>>2
That's recursive with memoization, faggot

Dynamic programming is the act of changing all your functions and variables in the middle of a project without telling anyone else on the project.

>>4
Not all, you'll alert them.
The best option is to swap two parameters of the same type.

Haskell. Haskell Nomads.

Hahah noobs

Haskell boobs!

(\dick -> (.)(.))

>>3
that's dynamic programming

>>10
Well, the course slides explicitly state that it's not, but I should take the arbitrary claim of an anonymous person on the internet over them I guess.

>>11
Memoization isn't really dynamic programming, but it's similar in principle. Memoization saves the results of *all* function calls whereas dynamic programming saves only those that will be needed again, and generally throws out a result that is no longer needed. Compare these two versions of fibs:

MEMOIZED:

fibt = {1, 1}
for i = 3, n do
  fibt[i] = fibt[i - 1] + fibt[i - 2]
end
return fibt[n]
DYNAMICALLY PROGRAMMED:

i, j = 1, 1
for i = 3, n do
  local t = i
  i = i + j
  j = t
end
return i
(the loop can be optimized to "i = i + j; j = i - j", but dealing with t explicitly helps to explain the logic behind what is going on)

The difference between the two is that in the memoized version all previous values are stored, whereas in the dynamically programmed version only the last two values are stored, since they are the only ones that will be necessary to calculate the next value. Of course, there are problems where dynamic programming is extremely difficult or impossible to implement, since it is very hard to know which values are no longer needed.

>>9
\dick -> (.) (.) :: t -> (a1 -> b -> c) -> a1 -> (a -> b) -> a -> c

Since "dick" is unused, it's simpler just to write (.) (.) :: (a1 -> b -> c) -> a1 -> (a -> b) -> a -> c, and it's easier to comprehend if you rename the type variables.

let boobs = (.) (.) :: (b -> c -> d) -> b -> (a -> c) -> a -> d

Lets name the arguments to "boobs" f, b, g and a. It is then likely equivalent to the following definition

let boobs f b g a = f b (g a)

>>13
You're forgetting the t ->.
Make it boobs = (.) (.) . const

>>12
A Lua programmer, in my Prague??

Too complicated for my taste.

>>15
TRY MY ANUS. It's not complicated at all. Just a hole with a pipe

>>13
Always interesting to know that the boobs operator is valid Haskal.

>>12
Almost right, except that it's exactly the other way around.

Yes, yes, IHBT.

>>14
Only languages worth using, except for fibs bullshit, are C, Lua, and Scheme.

>>19
Lua
U MENA HASKAL?

>>19
I'm not sure why I don't see ^BBCode on that list...

>>21
BBCode doesn't support tail recursion.

I use ruby all the time . It's so hipster and cool... oh yeah and im learning japanese and my japanese teacher is so kawaii.. and i've just bought a bento box.. desu desu

>>23
Post rating: ★☆☆☆☆
Try harder next time!

^{Back to /b/, ``GNAA Faggot''}

Xarn is a bad boyfriend

>>24
Did you use Labia Cleaver's cheeseburger rounding algorithm?

>>29
I was about to say that, fagshit.

>>29,30
I refrained from posting it, imbeciles.

1  Name: Anonymous : 2009-12-16 12:05
28  Name: Anonymous : 2012-11-25 14:11
stanley resurrects another dead thread.