1593683040

What is the Fibonacci Sequence? The Fibonacci Sequence refers to a sequence of numbers in which each succeeding number is the sum of the two preceding numbers while keeping a golden ratio. The golden ratio in math refers to the ratio between two numbers being the same as the ratio as another set of numbers. You’ve probably heard about it before in a math class. Keep in mind; I’m going to be explaining how to create the Fibonacci Sequence as an algorithm. Here’s what it looks like.

```
Fibonacci Sequence:
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144
1 + 1 = 2
2 + 3 = 5
3 + 5 = 8
5 + 8 = 13
8 + 13 = 21
13 + 21 = 34
21 + 34 = 55
34 + 55 = 89
55 + 89 = 144
... and so on to infinity
```

Calculating the next number is as simple as Fn = Fn-1 + Fn — 2.

Let’s now start figuring how to create the algorithm. Pretend as if an interviewer asked us to create a Fibonacci Sequence algorithm that takes in a number as an argument. The purpose of the algorithm is to use that number (which represents the index) and to return the value for said index number.

```
function fibonacciSequence(index) {
}
```

Now we have a simple empty function. Now let’s ask ourselves what we know about the Fibonacci Sequence. We know the current value is determined using the past two values and the first two values is 1. That means 0 was added between those two values. Let’s now create variables to represent those values including a variable to represent the Fn which does not have a set value.

```
function fibonacciSequence(index) {
let a = 1
let b = 0
let currentValue
}
```

#javascript #algorithms

1594351020

Today, we’ll solve the previous Fibonacci problem using the dreaded recursion approach. A little bit of theory was explored in this video, and today, I’ll straight to the point

Just to remember:

- A recursive method is a method that calls itself.
- A recursive method usually solves a smallest version of the bigger (original) problem.

When it comes to Fibonacci, the definition already gives us a hint of how to solve it recursively:

To get the next number in a sequence, you have to sum the previous two numbers

Let’s say that we want the first 8 numbers in the Fibonacci sequence:

Plain Text

1

```
0 1 1 2 3 5 8 13
```

Notice that to get the value 13, we need to first calculate the first 7 numbers of a Fibonacci sequence. But to get the value 8, we need to first calculate the first 6 numbers of a Fibonacci sequence. And to get the value 5, we need to first calculate the first 5 numbers of a Fibonacci sequence.

Yup, you got it : ) We need to calculate the Fibonacci number of the previous 2 numbers

#ruby #programming #coding #ruby on rails #algorithm #recursion #fibonacci #tutorial for beginners #algorithm analysis

1594674000

Hey friends!

This is the blog post version of the Youtube video from the 30 Ruby Coding Challenges in 30 Days series

It’s time to organize the kitchen and to get a better code design to solve the Fibonacci Sequence, which was the previous coding challenge:

We want to calculate the first N numbers in a Fibonacci sequence

This was the last coding solution:

Ruby

```
def fibonacci(count)
```

n1 = 0

```
n2 = 1
```

sequence = [n1, n2]

```
while count > 2
```

# sum of the previous 2 numbers

```
n3 = n1 + n2
```

sequence.push(n3)

```
# assigning the new numbers to calculate the next number in the sequence
```

n1 = n2

```
n2 = n3
```

count = count - 1

```
end
```

return sequence

```
end
```

puts fibonacci(8)

```
# 0 1 1 2 3 5 8 13
```
You can be honest, it's not that great.
## The Ruby Way to Solve the Fibonacci Problem
### **Step 1**
Ruby allows us to go from one number to another in a sequence like this:
Ruby
```
(0..10).each do |number|
```

end

```
In our example we want to avoid the count mutation (fancy name for change). We can do that by the following code:
Ruby
```

(0…count).each do |number|

```
end
```
That’s great because Ruby will **automatically iterate over the array**
### **Step 2**
A better way to store the number in the sequence would be:
Ruby
```
sequence << number if number <= 1
```

sequence << sequence[-1] + sequence[-2] if sequence.length >= 2

```
The complete code, a little bit leaner with a better strategy, would be:
Ruby
```

def fibonacci(count)

```
sequence = []
```

(0…count).each do |number|

```
sequence << number if number <= 1
```

sequence << sequence[-1] + sequence[-2] if sequence.length >= 2

```
end
```

sequence

```
end
```
Fantastic! Ruby deals with the problem really well!
```

#ruby #programming #coding #ruby on rails #algorithm #fibonacci #tutorial for beginners #algorithm analysis #coding basics #coding challenges

1594745940

Hey friends!

This is the blog post version of the Youtube video from the 30 Ruby Coding Challenges in 30 Days series

Today, we want to solve the previous problem in a more Ruby Way

I want to sum all even numbers in a Fibonacci sequence

This was the last algorithm version of the problem:

Ruby

```
def fibonacci_sum(count)
```

sum = 0

```
number = 0
```

sequence = []

```
(0..count).each do |item|
```

number = item if item <= 1

```
number = sequence[-1] + sequence[-2] if item > 1
```

sequence << number

```
sum += number if number % 2 == 0
```

end

```
sum
```

end

```
The code is not that great for a couple of reasons:
* Too many local variables to manipulate.
* Two main responsibilities: create the Fibonacci sequence **AND** validate even numbers.
The two main reasons above leave us with code that's difficult to read, and therefore, difficult to maintain. Fewer friends in our team, right?
I’m going to try to get rid of these problems. Let’s get into it!
## Better Algorithm Version - Ruby Way
I’m going to break the refactoring into a few small steps
### **Step 1 - Splitting Responsibilities**
Let’s create a new method do generate only the Fibonacci sequence
Ruby
```

def fibonacci(count)

```
sequence = []
```

(0…count).each do |number|

```
sequence << number if number <= 1
```

sequence << sequence[-1] + sequence[-2] if number > 1

```
end
```

sequence

```
end
```
Then we’re going to create the method to sum even numbers based on the generated sequence
Ruby
```
def fibonacci(count)
```

sequence = []

```
(0..count).each do |number|
```

sequence << number if number <= 1

```
sequence << sequence[-1] + sequence[-2] if number > 1
```

end

```
sequence
```

end

```
def sum(array)
```

# magic here

```
end
```

puts sum(fibonacci(10))

```
### **Step 2 - Sum of Even Numbers**
Now, we just need to sum all the even numbers, given an array of numbers.
As we did [previously here](https://youtu.be/Y3W64fXmfkw), I’m going to use a Ruby symbol, which allows us to reduce a list of items into a single number by applying an operation:
Ruby
```

def sum(array)

```
array.select { |number| number % 2 == 0 }.reduce(:+)
```

end

```
The complete code would be:
Ruby
```

def fibonacci(count)

```
sequence = []
```

(0…count).each do |number|

```
sequence << number if number <= 1
```

sequence << sequence[-1] + sequence[-2] if number > 1

```
end
```

sequence

```
end
```

def sum(array)

```
array.select { |number| number % 2 == 0 }.reduce(:+)
```

end

```
puts sum(fibonacci(10))
```
```

#ruby #programming #coding #ruby on rails #algorithm #fibonacci #tutorial for beginners #algorithm analysis #coding basics

1593347004

The Greedy Method is an approach for solving certain types of optimization problems. The greedy algorithm chooses the optimum result at each stage. While this works the majority of the times, there are numerous examples where the greedy approach is not the correct approach. For example, let’s say that you’re taking the greedy algorithm approach to earning money at a certain point in your life. You graduate high school and have two options:

#computer-science #algorithms #developer #programming #greedy-algorithms #algorithms

1596427800

Finding a certain piece of text inside a document represents an important feature nowadays. This is widely used in many practical things that we regularly do in our everyday lives, such as searching for something on Google or even plagiarism. In small texts, the algorithm used for pattern matching doesn’t require a certain complexity to behave well. However, big processes like searching the word ‘cake’ in a 300 pages book can take a lot of time if a naive algorithm is used.

Before, talking about KMP, we should analyze the inefficient approach for finding a sequence of characters into a text. This algorithm slides over the text one by one to check for a match. The complexity provided by this solution is O (m * (n — m + 1)), where m is the length of the pattern and n the length of the text.

Find all the occurrences of string pat in string txt (naive algorithm).

```
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
string pat = "ABA"; // the pattern
string txt = "CABBCABABAB"; // the text in which we are searching
bool checkForPattern(int index, int patLength) {
int i;
// checks if characters from pat are different from those in txt
for(i = 0; i < patLength; i++) {
if(txt[index + i] != pat[i]) {
return false;
}
}
return true;
}
void findPattern() {
int patternLength = pat.size();
int textLength = txt.size();
for(int i = 0; i <= textLength - patternLength; i++) {
// check for every index if there is a match
if(checkForPattern(i,patternLength)) {
cout << "Pattern at index " << i << "\n";
}
}
}
int main()
{
findPattern();
return 0;
}
view raw
main6.cpp hosted with ❤ by GitHub
```

This algorithm is based on a degenerating property that uses the fact that our pattern has some sub-patterns appearing more than once. This approach is significantly improving our complexity to linear time. The idea is when we find a mismatch, we already know some of the characters in the next searching window. This way we save time by skip matching the characters that we already know will surely match. To know when to skip, we need to pre-process an auxiliary array prePos in our pattern. prePos will hold integer values that will tell us the count of characters to be jumped. This supporting array can be described as the longest proper prefix that is also a suffix.

#programming #data-science #coding #kmp-algorithm #algorithms #algorithms