 1594351020

# Day 15 of 30 Ruby Coding Challenge - Fibonacci Sequence Recursively

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

## Fibonacci Recursively in Theory

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

## Buddha Community  1675304280

## Introduction

We are back with another exciting and much-talked-about Rails tutorial on how to use Hotwire with the Rails application. This Hotwire Rails tutorial is an alternate method for building modern web applications that consume a pinch of JavaScript.

Rails 7 Hotwire is the default front-end framework shipped with Rails 7 after it was launched. It is used to represent HTML over the wire in the Rails application. Previously, we used to add a hotwire-rails gem in our gem file and then run rails hotwire: install. However, with the introduction of Rails 7, the gem got deprecated. Now, we use turbo-rails and stimulus rails directly, which work as Hotwire’s SPA-like page accelerator and Hotwire’s modest JavaScript framework.

## What is Hotwire?

Hotwire is a package of different frameworks that help to build applications. It simplifies the developer’s work for writing web pages without the need to write JavaScript, and instead sending HTML code over the wire.

Introduction to The Hotwire Framework:

### 1. Turbo:

It uses simplified techniques to build web applications while decreasing the usage of JavaScript in the application. Turbo offers numerous handling methods for the HTML data sent over the wire and displaying the application’s data without actually loading the entire page. It helps to maintain the simplicity of web applications without destroying the single-page application experience by using the below techniques:

Turbo Frames: Turbo Frames help to load the different sections of our markup without any dependency as it divides the page into different contexts separately called frames and updates these frames individually.
Turbo Drive: Every link doesn’t have to make the entire page reload when clicked. Only the HTML contained within the tag will be displayed.
Turbo Streams: To add real-time features to the application, this technique is used. It helps to bring real-time data to the application using CRUD actions.

### 2. Stimulus

It represents the JavaScript framework, which is required when JS is a requirement in the application. The interaction with the HTML is possible with the help of a stimulus, as the controllers that help those interactions are written by a stimulus.

Not much information is available about Strada as it has not been officially released yet. However, it works with native applications, and by using HTML bridge attributes, interaction is made possible between web applications and native apps.

Simple diagrammatic representation of Hotwire Stack: ## Prerequisites For Hotwire Rails Tutorial

As we are implementing the Ruby on Rails Hotwire tutorial, make sure about the following installations before you can get started.

• Ruby on Rails
• Hotwire gem
• PostgreSQL/SQLite (choose any one database)
• Turbo Rails
• Stimulus.js

Looking for an enthusiastic team of ROR developers to shape the vision of your web project?
Contact Bacancy today and hire Ruby developers to start building your dream project!

## Create a new Rails Project

Find the following commands to create a rails application.

``````mkdir ~/projects/railshotwire
cd ~/projects/railshotwire
echo "source 'https://rubygems.org'" > Gemfile
echo "gem 'rails', '~> 7.0.0'" >> Gemfile
bundle install
bundle exec rails new . --force -d=postgresql``````

Now create some files for the project, up till now no usage of Rails Hotwire can be seen.
Fire the following command in your terminal.

• For creating a default controller for the application
``````echo "class HomeController < ApplicationController" > app/controllers/home_controller.rb
echo "end" >> app/controllers/home_controller.rb``````
• For creating another controller for the application
``````echo "class OtherController < ApplicationController" > app/controllers/other_controller.rb
echo "end" >> app/controllers/home_controller.rb``````
• For creating routes for the application
``````echo "Rails.application.routes.draw do" > config/routes.rb
echo '  get "home/index"' >> config/routes.rb
echo '  get "other/index"' >> config/routes.rb
echo '  root to: "home#index"' >> config/routes.rb
echo 'end' >> config/routes.rb``````
• For creating a default view for the application
``````mkdir app/views/home
echo '<h1>This is Rails Hotwire homepage</h1>' > app/views/home/index.html.erb
echo '<div><%= link_to "Enter to other page", other_index_path %></div>' >> app/views/home/index.html.erb
``````
• For creating another view for the application
``````mkdir app/views/other
echo '<h1>This is Another page</h1>' > app/views/other/index.html.erb
``````
• For creating a database and schema.rb file for the application
``````bin/rails db:create
bin/rails db:migrate``````
• For checking the application run bin/rails s and open your browser, your running application will have the below view. Additionally, you can clone the code and browse through the project. Here’s the source code of the repository: Rails 7 Hotwire application

Now, let’s see how Hotwire Rails can work its magic with various Turbo techniques.

## Hotwire Rails: Turbo Drive

Now click on go to another page link that appears on the home page to redirect from the home page to another page. In our Network tab, we can see that this action of navigation is achieved via XHR. It appears only the part inside HTML is reloaded, here neither the CSS is reloaded nor the JS is reloaded when the navigation action is performed. By performing this action we can see that Turbo Drive helps to represent the HTML response without loading the full page and only follows redirect and reindeer HTML responses which helps to make the application faster to access.

## Hotwire Rails: Turbo Frame

This technique helps to divide the current page into different sections called frames that can be updated separately independently when new data is added from the server.
Below we discuss the different use cases of Turbo frame like inline edition, sorting, searching, and filtering of data.

Let’s perform some practical actions to see the example of these use cases.

Make changes in the app/controllers/home_controller.rb file

#CODE

``````class HomeController < ApplicationController
def turbo_frame_form
end

def turbo_frame submit
extracted_anynumber = params[:any][:anynumber]
render :turbo_frame_form, status: :ok, locals: {anynumber: extracted_anynumber,      comment: 'turbo_frame_submit ok' }
end
end`````` Add app/views/home/turbo_frame_form.html.erb file to the application and add this content inside the file.

#CODE

``````<section>

<%= turbo_frame_tag 'anyframe' do %>

<div>
<h2>Frame view</h2>
<%= form_with scope: :any, url: turbo_frame_submit_path, local: true do |form| %>
<%= form.label :anynumber, 'Type an integer (odd or even)', 'class' => 'my-0  d-inline'  %>
<%= form.text_field :anynumber, type: 'number', 'required' => 'true', 'value' => "#{local_assigns[:anynumber] || 0}",  'aria-describedby' => 'anynumber' %>
<%= form.submit 'Submit this number', 'id' => 'submit-number' %>
<% end %>
</div>
<div>
<h2>Data of the view</h2>
<pre style="font-size: .7rem;"><%= JSON.pretty_generate(local_assigns) %></pre>
</div>

<% end %>

</section>`````` #CODE

``````Rails.application.routes.draw do
get 'home/index'
get 'other/index'

get '/home/turbo_frame_form' => 'home#turbo_frame_form', as: 'turbo_frame_form'
post '/home/turbo_frame_submit' => 'home#turbo_frame_submit', as: 'turbo_frame_submit'

root to: "home#index"
end``````
• Next step is to change homepage view in app/views/home/index.html.erb

#CODE

``````<h1>This is Rails Hotwire home page</h1>
<div><%= link_to "Enter to other page", other_index_path %></div>

<%= turbo_frame_tag 'anyframe' do %>
<div>
<h2>Home view</h2>
<%= form_with scope: :any, url: turbo_frame_submit_path, local: true do |form| %>
<%= form.label :anynumber, 'Type an integer (odd or even)', 'class' => 'my-0  d-inline'  %>
<%= form.text_field :anynumber, type: 'number', 'required' => 'true', 'value' => "#{local_assigns[:anynumber] || 0}",  'aria-describedby' => 'anynumber' %>
<%= form.submit 'Submit this number', 'id' => 'submit-number' %>
<% end %>
<div>
<% end %>`````` After making all the changes, restart the rails server and refresh the browser, the default view will appear on the browser. Now in the field enter any digit, after entering the digit click on submit button, and as the submit button is clicked we can see the Turbo Frame in action in the below screen, we can observe that the frame part changed, the first title and first link didn’t move. ## Hotwire Rails: Turbo Streams

Turbo Streams deliver page updates over WebSocket, SSE or in response to form submissions by only using HTML and a series of CRUD-like operations, you are free to say that either

• Update the piece of HTML while responding to all the other actions like the post, put, patch, and delete except the GET action.
• Transmit a change to all users, without reloading the browser page.

This transmit can be represented by a simple example.

• Make changes in app/controllers/other_controller.rb file of rails application

#CODE

``````class OtherController < ApplicationController

def post_something
respond_to do |format|
format.turbo_stream {  }
end
end

end`````` Add the below line in routes.rb file of the application

#CODE

``post '/other/post_something' => 'other#post_something', as: 'post_something'``

Superb! Rails will now attempt to locate the app/views/other/post_something.turbo_stream.erb template at any moment the ‘/other/post_something’ endpoint is reached.

For this, we need to add app/views/other/post_something.turbo_stream.erb template in the rails application.

#CODE

``````<turbo-stream action="append" target="messages">
<template>
<div id="message_1">This changes the existing message!</div>
</template>
</turbo-stream>
``````

This states that the response will try to append the template of the turbo frame with ID “messages”.

Now change the index.html.erb file in app/views/other paths with the below content.

#CODE

``````<h1>This is Another page</h1>

<div style="margin-top: 3rem;">
<%= form_with scope: :any, url: post_something_path do |form| %>
<%= form.submit 'Post any message %>
<% end %>
<turbo-frame id="messages">
<div>An empty message</div>
</turbo-frame>
</div>``````
• After making all the changes, restart the rails server and refresh the browser, and go to the other page. • Once the above screen appears, click on the Post any message button This action shows that after submitting the response, the Turbo Streams help the developer to append the message, without reloading the page.

Another use case we can test is that rather than appending the message, the developer replaces the message. For that, we need to change the content of app/views/other/post_something.turbo_stream.erb template file and change the value of the action attribute from append to replace and check the changes in the browser.

#CODE

``````<turbo-stream action="replace" target="messages">
<template>
<div id="message_1">This changes the existing message!</div>
</template>
</turbo-stream>`````` When we click on Post any message button, the message that appear below that button will get replaced with the message that is mentioned in the app/views/other/post_something.turbo_stream.erb template ## Stimulus

There are some cases in an application where JS is needed, therefore to cover those scenarios we require Hotwire JS tool. Hotwire has a JS tool because in some scenarios Turbo-* tools are not sufficient. But as we know that Hotwire is used to reduce the usage of JS in an application, Stimulus considers HTML as the single source of truth. Consider the case where we have to give elements on a page some JavaScript attributes, such as data controller, data-action, and data target. For that, a stimulus controller that can access elements and receive events based on those characteristics will be created.

Make a change in app/views/other/index.html.erb template file in rails application

#CODE

``````<h1>This is Another page</h1>

<div style="margin-top: 2rem;">
<%= form_with scope: :any, url: post_something_path do |form| %>
<%= form.submit 'Post something' %>
<% end %>
<turbo-frame id="messages">
<div>An empty message</div>
</turbo-frame>
</div>

<div style="margin-top: 2rem;">
<h2>Stimulus</h2>
<div data-controller="hello">
<input data-hello-target="name" type="text">
<button data-action="click->hello#greet">
Greet
</button>
<span data-hello-target="output">
</span>
</div>
</div>`````` Make changes in the hello_controller.js in path app/JavaScript/controllers and add a stimulus controller in the file, which helps to bring the HTML into life.

#CODE

``````import { Controller } from "@hotwired/stimulus"

export default class extends Controller {
static targets = [ "name", "output" ]

greet() {
this.outputTarget.textContent =
`Hello, \${this.nameTarget.value}!`
}
}`````` Go to your browser after making the changes in the code and click on Enter to other page link which will navigate to the localhost:3000/other/index page there you can see the changes implemented by the stimulus controller that is designed to augment your HTML with just enough behavior to make it more responsive.

With just a little bit of work, Turbo and Stimulus together offer a complete answer for applications that are quick and compelling.

Using Rails 7 Hotwire helps to load the pages at a faster speed and allows you to render templates on the server, where you have access to your whole domain model. It is a productive development experience in ROR, without compromising any of the speed or responsiveness associated with SPA.

## Conclusion

We hope you were satisfied with our Rails Hotwire tutorial. Write to us at service@bacancy.com for any query that you want to resolve, or if you want us to share a tutorial on your query.

For more such solutions on RoR, check out our Ruby on Rails Tutorials. We will always strive to amaze you and cater to your needs.

Original article source at: https://www.bacancytechnology.com/ 1594674000

## Day 14 of 30 Ruby Coding Challenge - Fibonacci Sequence the Ruby Way

### Day 14 of 30. We’re going to solve the famous Fibonacci sequence in a more Ruby Way, which will be much better (hopefully!) than the previous solution

Hey friends!

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

## Fibonacci Sequence

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 1594351020

## Day 15 of 30 Ruby Coding Challenge - Fibonacci Sequence Recursively

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

## Fibonacci Recursively in Theory

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 1594745940

## Day 17 Ruby Coding Challenge - Sum Even Numbers in Fibonacci Sequence - DZone Web Dev

### Day 17 of 30. We’re going to sum all the even numbers in a given Fibonacci sequence using a better code design in Ruby

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

## Last Algorithm Version

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 1594449660

# Day 16 of 30 Ruby Coding Challenge - Sum Even Numbers in a Fibonacci Sequence

Hey friends!

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

We’ve solved the Fibonacci sequence herehere and here, which means that we have some clues of how to create a Fibonacci sequence :)

Today we want to be a little bit daring by solving the following problem:

I want to sum all even numbers in a Fibonacci sequence

## Fibonacci Sequence in Ruby

As you already know, this is one of the solutions:

Ruby

1

``````def fibonacci_sum(count)
``````

2

``````    number = 0
``````

3

``````  sequence = []
``````

4

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

5

``````    number = item if item <= 1
``````

6

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

7

``````    sequence << number
``````

8

``````  end
``````

9

``````    sequence
``````

10

``````end
``````

We’re returning a Fibonacci sequence, however, that’s not what we’re looking for

## Sum Even Numbers in a Fibonacci Sequence in Ruby

We’re going to:

• add a local variable called sum
• then update this variable only if the number is even
• return the sum variable

Ruby

1

``````def fibonacci_sum(count)
``````

2

``````  sum = 0
``````

3

``````    number = 0
``````

4

``````  sequence = []
``````

5

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

6

``````    number = item if item <= 1
``````

7

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

8

``````    sequence << number
``````

9

10

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

11

``````  end
``````

12

``````  sum
``````

13

``````end
``````

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