# Solved: How to Write a Program that Prints Fibonacci Numbers Repeatedly

• The article explains how to write a program that prints Fibonacci numbers repeatedly using Python as an example language.
• The article provides the algorithm, the code, the output, and the explanation of the solution, as well as some references and FAQ related to the topic.
• The article is intended for educational purposes only and the author is not liable for any errors or damages.

Fibonacci numbers are a sequence of numbers where each number is the sum of the previous two numbers. For example, the first 10 Fibonacci numbers are: 1, 1, 2, 3, 5, 8, 13, 21, 34, and 55. Fibonacci numbers have many applications in mathematics, computer science, and nature. They also make for a fun and challenging coding exercise.

In this article, I will show you how to write a program that prints Fibonacci numbers repeatedly until you stop it. This is a variation of the classic problem of generating Fibonacci numbers, which usually asks you to print a certain number of terms or up to a certain limit. Here, we will print an infinite stream of Fibonacci numbers until we interrupt the program manually.

I will use Python as the programming language for this task, but you can use any language you prefer. The logic and algorithm will be similar for most languages.

## The Algorithm

The algorithm for printing Fibonacci numbers repeatedly is simple:

• Initialize two variables to store the current and previous Fibonacci numbers. Let’s call them curr and prev. Set them both to 1 initially.
• Print curr to the output.
• Calculate the next Fibonacci number by adding curr and prev. Store the result in a temporary variable. Let’s call it next.
• Update prev to be equal to curr, and curr to be equal to next.
• Repeat steps 2 to 4 indefinitely.

## The Code

Here is the Python code that implements the algorithm:

``````# Initialize curr and prev
curr = 1
prev = 1

# Loop forever
while True:
# Print curr
print(curr)

# Calculate next
next = curr + prev

# Update curr and prev
curr = next
prev = curr - prev
``````

## The Output

Here is a sample output of running the code:

``````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

``````

To stop the program, you can press Ctrl+C on your keyboard or close the terminal window.

## The Explanation

Let’s break down the code and see how it works.

First, we initialize two variables curr and prev to store the current and previous Fibonacci numbers. We set them both to 1, which is the first Fibonacci number.

``````# Initialize curr and prev
curr = 1
prev = 1
``````

Next, we enter an infinite loop using the while True statement. This means that the loop will run forever unless we break out of it somehow.

``````# Loop forever
while True:
``````

Inside the loop, we print the current Fibonacci number using the print function. This will display the value of curr on the screen.

``````# Print curr
print(curr)
``````

Then, we calculate the next Fibonacci number by adding curr and prev. We store the result in a temporary variable called next.

``````# Calculate next
next = curr + prev
``````

For example, if curr is 3 and prev is 2, then next will be 5.

After that, we update curr and prev with the new values. We assign next to curr, and subtract prev from curr to get the new value of prev.

``````# Update curr and prev
curr = next
prev = curr - prev
``````

For example, if next is 5, then we assign it to curr, and subtract 2 from 5 to get 3 as the new value of prev.

This completes one iteration of the loop. We repeat this process until we stop the program manually.

## Frequently Asked Questions (FAQs)

Here are some frequently asked questions related to the topic of this article:

### Question: How can I write a program that prints Fibonacci numbers up to a certain limit?

Answer: You can modify the code by adding a condition to the loop that checks if the current Fibonacci number is less than or equal to the limit. For example, if you want to print Fibonacci numbers up to 100, you can write:

``````# Initialize curr and prev
curr = 1
prev = 1

# Loop until curr is greater than 100
while curr <= 100:
# Print curr
print(curr)

# Calculate next
next = curr + prev

# Update curr and prev
curr = next
prev = curr - prev
``````

### Question: How can I write a program that prints the nth Fibonacci number?

Answer: You can modify the code by adding a counter variable that keeps track of how many Fibonacci numbers have been printed. For example, if you want to print the 10th Fibonacci number, you can write:

``````# Initialize curr, prev, and counter
curr = 1
prev = 1
counter = 1

# Loop until counter is equal to 10
while counter < 10:
# Calculate next
next = curr + prev

# Update curr, prev, and counter
curr = next
prev = curr - prev
counter += 1

# Print curr
print(curr)
``````

### Question: How can I write a program that prints Fibonacci numbers in reverse order?

Answer: You can modify the code by using a list to store the Fibonacci numbers as they are generated, and then print the list in reverse order. For example, if you want to print the first 10 Fibonacci numbers in reverse order, you can write:

``````# Initialize curr, prev, and list
curr = 1
prev = 1
fib_list = []

# Loop 10 times
for i in range(10):
# Append curr to the list
fib_list.append(curr)

# Calculate next
next = curr + prev

# Update curr and prev
curr = next
prev = curr - prev

# Print the list in reverse order
for num in reversed(fib_list):
print(num)
``````

## Conclusion

I hope you enjoyed this article and learned something new. If you have any questions, comments, or feedback, please feel free to leave them below. Thank you for reading!

Disclaimer: This article is for educational purposes only. The code and information provided here are not guaranteed to be correct, complete, or optimal. The author is not responsible for any errors, omissions, or damages that may arise from using or modifying the code or information. Use at your own risk.

### Alex Lim

Alex Lim is a certified IT Technical Support Architect with over 15 years of experience in designing, implementing, and troubleshooting complex IT systems and networks. He has worked for leading IT companies, such as Microsoft, IBM, and Cisco, providing technical support and solutions to clients across various industries and sectors. Alex has a bachelor’s degree in computer science from the National University of Singapore and a master’s degree in information security from the Massachusetts Institute of Technology. He is also the author of several best-selling books on IT technical support, such as The IT Technical Support Handbook and Troubleshooting IT Systems and Networks. Alex lives in Bandar, Johore, Malaysia with his wife and two chilrdren. You can reach him at [email protected] or follow him on Website | Twitter | Facebook

#### Your Support Matters...

We run an independent site that is committed to delivering valuable content, but it comes with its challenges. Many of our readers use ad blockers, causing our advertising revenue to decline. Unlike some websites, we have not implemented paywalls to restrict access. Your support can make a significant difference. If you find this website useful and choose to support us, it would greatly secure our future. We appreciate your help. If you are currently using an ad blocker, please consider disabling it for our site. Thank you for your understanding and support.