To answer you first question: (defn fib ([n] (fib [0 1] n)) ([x, n] (if (< (count x) n) (fib (conj x (+ (last x) (nth x (- (count x) 2)))) n) x))) This type of function definition is called multi-arity function definition. You can learn more about it here: http://clojure.org/functional_programming As for a better … Read more
Here’s another way: (defn factorial [n] (reduce * (range 1 (inc n)))) This won’t blow the stack because range returns a lazy seq, and reduce walks across the seq without holding onto the head. reduce makes use of chunked seqs if it can, so this can actually perform better than using recur yourself. Using Siddhartha … Read more
That question is like asking what’s the difference between a car and a DeLorean. In recursion function calls itself until reaches a base case. In backtracking you use recursion in order to explore all the possibilities until you get the best result for the problem. Can be a bit hard to understand, I attach some … Read more
This illustration is in English, rather than an actual programming language, but is useful for explaining the process in a non-technical way: A child couldn’t sleep, so her mother told a story about a little frog, who couldn’t sleep, so the frog’s mother told a story about a little bear, who couldn’t sleep, so bear’s … Read more
You need to capture the state in some accumulators and update the state at each iteration. If you have experience in an imperative language, imagine writing a while loop and tracking information in variables during each iteration of the loop. What variables would you need? How would you update them? That’s exactly what you have … Read more
Your definition is perfectly fine. It’s a known issue with rendering recursive schemas in Swagger Editor and Swagger UI: https://github.com/swagger-api/swagger-ui/issues/3325 To work around the “Example Value” showing null/”string”/undefined instead of a recursive element, you can add a custom example to your schema: definitions: TreeNode: type: object properties: name: type: string description: The name of the … Read more
For the most part recursion is slower, and takes up more of the stack as well. The main advantage of recursion is that for problems like tree traversal it make the algorithm a little easier or more “elegant”. Check out some of the comparisons: link
It is not possible to recur on anonymous functions in Elixir. Erlang 17 (currently a release candidate) adds this possibility to Erlang and we plan to leverage it soon. Right now, the best approach is to define a module function and pass it around: def neural_bias([i|input],[w|weights], acc) do neural(input,weights,i*w+acc) end def neural_bias([], [bias], acc) do … Read more
You’re being hit by filter‘s laziness. Change (filter …) to (doall (filter …)) in your recur form and the problem should go away. A more in-depth explanation: The call to filter returns a lazy seq, which materialises actual elements of the filtered seq as required. As written, your code stacks filter upon filter upon filter…, … Read more
There is an interesting way to do it that does rely neither on rebinding nor the behavior of def. The main trick is to go around the limitations of recursion by passing a function as an argument to itself: (defn make-fibo [y] (let [fib (fn [mem-fib x] (let [fib (fn [a] (mem-fib mem-fib a))] (if … Read more