Este lo hice en cobol (programación estructurada):
Visión agnóstica de la programación
Importancia de los paradigmas en la historia de la programación
Máquina abstracta: flujo de datos en computadoras digitales conceptuales
Lenguajes de programación vs. lenguaje natural
Paradigmas de programación imperativos
¿Qué son los paradigmas de programación?
¿Cuáles son los principales paradigmas de programación?
Programación estructurada
Programación procedural
Programación orientada a objetos
Paradigmas de programación declarativos
Programación funcional
Programación lógica
Otros paradigmas o modelos de computación
Programación dirigida por eventos
Programación concurrente
Problemas de la concurrencia
Historia de los lenguajes de programación
Década de los 40: primeras computadoras y lenguajes ensambladores
Década de los 50: Fortran y Algol
Década de los 60: LISP, COBOL, Simula
Década de los 70: C, Pascal, Smalltalk, Prolog, Meta Language
Década de los 80: computadoras personales, POO, C++, Python
Década de los 90: desarrollo web, Java, JavaScript
Siguientes pasos
Comparación entre lenguajes y paradigmas de programación
Continúa aprendiendo paradigmas y lenguajes de programación
Aún no tienes acceso a esta clase
Crea una cuenta y continúa viendo este curso
Aportes 84
Preguntas 1
Este lo hice en cobol (programación estructurada):
Listo el reto de Fibonacci, lo hice en JavaScript:
function Fibonacci (n) {
let siguiente = 2;
let fibonacci = [0, 1];
while ( siguiente < Number(n) ) {
let suma = Number(fibonacci[ siguiente - 2 ] + fibonacci[ siguiente - 1 ]);
fibonacci.push(suma);
siguiente++;
}
for (let i = 0; i < fibonacci.length; i++) {
const element = fibonacci[i];
console.log(`Iteración número ${i} : ${element}`);
}
}
const cantidad = prompt('Cantidad de números');
Fibonacci(cantidad);
Aquí está el reto de la serie de Fibonacci hecho en Python.
function Fibonacci(num){
let num1 = 0, num2 = 1, sigNum;
console.log("Secuencia Fibonacci: ");
for(let i = 1; i <= num; i++){
console.log(num1)
sigNum = num1 + num2
num1 = num2
num2 = sigNum
}
}
const cantIteracion = prompt("Ingrese la cantidad de términos de la secuencia: (numero positivo) ");
Fibonacci(cantIteracion);
La arquitectura de Von Neuman es en la que se basan nuestros procesadores, una maquina puede almacenar un programa y las datos del programa, esta organizada de la siguiente manera:
Secuencia de Fibonacci en Python
Programación estructurada
Características del lenguaje imperativo
recuerdo en la secundaria, las primeras líneas en C
Antes de programar es bueno crear tu diagrama de secuencia para comprender el flujo del programa a desarrollar.
Les comparto mi codigo del reto.
💙 Utilizando Dart para representar el algoritmo de Fibonacci. DartPad para ver el funcionamiento del código: https://dartpad.dev/
void main(){
int n = 8;
int fib0 = 0;
int fib1 = 1;
while(n>0){
int temp = fib0;
fib0 = fib1;
fib1 = fib1 + temp;
print(fib0);
n = n - 1;
}
}
Pondré uno en JS porque quiero ser popular…
Lo dejo en Python
def run():
pass
def fibonacci(n):
if n == 0 or n == 1:
return 1
return fibonacci(n - 1) + fibonacci(n - 2)
n = int(input("Ingrese un Numero: "))
print(f' El fibonacci de {n} es {fibonacci(n)}')
if __name__ == '__main__':
run()
Programación estructurada
La programación estructurada es un paradigma de programación orientado a mejorar la claridad, calidad y tiempo de desarrollo de un programa de computadora recurriendo únicamente a subrutinas y tres estructuras básicas: secuencia, selección (if y switch) e iteración (bucles for y while); asimismo, se considera innecesario y contraproducente el uso de la instrucción de transferencia incondicional (GOTO), que podría conducir a código espagueti, mucho más difícil de seguir y de mantener, y fuente de numerosos errores de programación.
El reto de Fibonacci en lenguaje C
#include <stdio.h>
int main()
{
printf("Secuencia Fibonacci\n");
int first = 0;
int second = 1;
int suma = 0;
int limit;
printf("Selecciona la posición limite\n");
scanf("%i", &limit);
for (int i = 1; i <= limit; i++)
{
printf("La posición %i de fibonacci es: %i \n", i, suma);
suma = first + second;
second = first;
first = suma;
}
return 0;
}
Nace de la programación secuencial (linea x linea) esto a mitad de los años 40’s cuando se reconoce que sus datos podrían residir en la memoria de una pc "Arquitectura de Von Neuman"
Una computadora puede almacenar un dato como los mismos que se generan a partir de él.
*Estructuras de Control:
.-Unidad Logica
.-Memoria
.-Dispositivo entrada
.-Dispositivo salida
*Características del lenguaje imperativo
.-Estructuras de control.
.-Manejo de errores y abstracciones.
.-Abstracción de procedimientos.
.-Expresión y asignación.
.-Soporte para estructura de datos.
ej: Fortran COBOL, Ada, Perl.
var n = 8;
var fib0 = 0;
var fib1 = 1;
while (n > 0){
var temp = fib0;
fib0 = fib1;
fib1 = fib1 + temp;
n = n-1;
console.log(fib0+" “+fib1+” "+n)
}
console.log("Resultado es "+fib0)
El resultado para ecuación cuando n vale 8 fue 21
Ejercicio en Python:
n = 8
fib0 = 0
fib1 = 1
while n > 0:
temp = fib0
fib0 = fib1
fib1 += temp
n -= 1
print(fib0)
Les comparto mi codigo, es igual al algoritmo de la clase 😃
var n =8;
fib0 = 0;
fib1 = 1;
while(n > 0){
temp = fib0;
fib0 = fib1;
fib1 = fib1 + temp;
n = n - 1;
}
console.log("El resutado es " + fib0);
function reto() {
var n=8;
var fib0=0;
var fib1=1;
var temp = 0;
while (n>=0) {
temp=fib0;
fib0=fib1;
fib1= fib1+temp;
n=n-1;
console.log(temp)
}
alert("Resultado "+fib0)
}
reto();
Función para el cálculo de números Fibonacci en R
Fibonacci <- function(x) {
fib<<-as.integer(c(0,1))
for (i in 1:x) {
fib<<-append(fib,(fib[i+1])+(fib[i]))
}
return(fib)
}
x
es la posición del numero a calcular en la secuencia Fibonacci partiendo desde el 1, no se toman en cuenta las primeras dos posiciones que, para este caso, son la base de todos los demás números, es decir el 0 y el 1.
Acá un ejemplo de los resultados que arroja tras su ejecución
Fibonacci(10)
[1] 0 1 1 2 3 5 8 13 21 34 55 89
Dejo mi aporte, lo hice en js
En python
def fibonacci(n):
if n == 0:
v = 0
elif n == 1:
v = 1
else:
v = fibonacci(n - 1) + fibonacci(n - 2)
return v
while (True):
try:
numero = int(input("Ingrese el numero: "))
if numero>=0:
print(fibonacci(numero))
break
else:
print("Ingresa un valor mayor o igual a cero.")
continue
except ValueError:
print("Intente con un numero valido.")
Reto en C
#include <stdio.h>
int main(int argn,char * arg[])
{
int n;
printf("introduzca cuantos numeros calcular: ");
scanf("%i",&n);
fibonacci(n);
return 0;
}
void fibonacci( int n )
{
int fib0 = 0;
int fib1 = 1;
while(n>0)
{
int temp = fib0;
fib0 = fib1;
fib1 +=temp;
n--;
}
printf("el valor de la posicion %i, en la serie de fibonacci es de: [%i]\n", n, fib0);
}
Esto fue lo que se me ocurrió, lo hice en JavaScript:
lista=[0,1];
var n = 1;
function sucesion(){
x = lista[n]+lista[(n-1)];
lista.push(x);
n++;
}
sucesion();
El reto en el paradigma funcional usando SigmaF 😃
let fibonacci_fn = fn x::int -> int {
if x <= 2 then {
=> 1;
}
=> fibonacci_fn(x - 2) + fibonacci_fn(x - 1);
}
printLn(fibonacci_fn(1)) -- Output: 1
printLn(fibonacci_fn(2)) -- Output: 1
printLn(fibonacci_fn(3)) -- Output: 2
printLn(fibonacci_fn(4)) -- Output: 3
...
printLn(fibonacci_fn(6)) -- Output: 8
Mi solución usando los métodos de los arrays en JS:
function fibonacci(n) {
return Array(n)
.fill()
.reduce((acc, _, index) => {
if(index === 0 || index === 1) acc.push(1)
if(index >= 2) acc.push((acc[index - 2]) + (acc[index - 1]))
return acc;
}, []);
}
console.log(fibonacci(9))
// output
// [ 1, 1, 2, 3, 5, 8, 13, 21, 34 ]
Aquí mi aporte en VBA 😁😎
Sub Fibbonacci()
Dim n, fib0, fib1, temp, result As Integer
n = 8
fib0 = 0
fib1 = 1
Do While n > 0
temp = fib0
fib0 = fib1
fib1 = fib1 + temp
n = n - 1
Loop
result = fib0
Debug.Print result
End Sub
Creo que así estoy bien, esta escrito en Go
func Fibonacci(n int) []int {
fibonnaci := []int{1, 1}
{
for len(fibonnaci) < n {
n1 := fibonnaci[len(fibonnaci)-2]
n2 := fibonnaci[len(fibonnaci)-1]
{
siguiente := n1 + n2
fibonnaci = append(fibonnaci, siguiente)
}
}
return fibonnaci
}
}
ALU: Unidad Aritmético Lógica, es un circuito digital que realiza operaciones aritméticas y operaciones lógicas entre los valores de los argumentos.
Abstracción de procedimientos: le permite al programador separar claramente el cómo del qué: una subrutina contiene la lógica necesaria para ejecutar una tarea, y sus parámetros son los objetos sobre los que trabaja.
Realizar el código para el algoritmo de Fibonacci
n = int(input("Ingrese la posición que desea conocer: "))
fibo0 = 0
fibo1 = 1
while n > 0:
temp = fibo0
fibo0 = fibo1
fibo1 += temp
n = n - 1
print("El numero fibonacci es " + str(fibo0))
Hecho en JavaScript
function fibonacci(num) {
if ( num === 0 || num === 1) {
return [0];
} else {
let fibonacci = [0, 1];
let count = 0;
while (count < num - 2) {
let currentNumber = fibonacci[count] + fibonacci[count + 1];
fibonacci.push(currentNumber);
count++;
}
return fibonacci;
}
}
En haskell
Hola a todos, dejo mi reto hecho en Java.
import java.util.Scanner;
/**
*
* @author Neider Silva
*/
public class SerieFibonacci {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int a = 0;
int b = 1;
int orden;
int succesion;
Scanner sc = new Scanner(System.in);
System.out.println("| SERIE DE FIBONNACCI |");
System.out.println(">>INGRESE EL ORDEN DE LA SERIE:");
orden = sc.nextInt();
System.out.println("\n******************");
switch(orden) {
case 1:
System.out.println(a);
break;
case 2:
System.out.println(a);
System.out.println(b);
break;
default:
System.out.println(a);
System.out.println(b);
for(int i = 0; i<orden-2; i++){
succesion = a+b;
System.out.println(succesion);
a = b;
b = succesion;
}
break;
}
System.out.println("******************");
}
}
Python
def fibonacci_recursivo(n):
if n <= 1:
return 1
return fibonacci_recursivo(n-1) + fibonacci_recursivo(n-2)
def main():
for a in range(10):
print(fibonacci_recursivo(a))
print(fibonacci_recursivo(a))
if __name__ == "__main__":
main()
Asi se vería en Javascript:
Y esta es la salida del programa:
Ya que para la sucesión de fibonacci debemos sumar el numero con el anterior, pues lo hice así:
var fbc = [0, 1];
for(let i = 0; i < 13; i++){
var c = fbc[i] + fbc[i+1];
fbc.push(c);
}
console.log(fbc);
Fibonacci en python
def fibonacci(max: int):
fib0, fib1 = (1, 0)
while fib0 <= max:
temp, fib1 = (fib1, fib0)
fib0 = temp + fib1
print(fib0)
fibonacci(8)
<var n = 8;
var fib0 = 0;
var fib1 = 1;
while (n > 0) {
var temp = fib0;
fib0 = fib1;
fib1 = fib1 + temp;
console.log(fib0 + fib1 + n);
n = n -1;
}>
// fibonacci cada numero es la suma del an
var numero1 = 0;
var numero2 = 1;
var resultado = 0;
function fibonacci() {
resultado = numero1 + numero2; //1
numero1 = numero2; // 0
numero2 = resultado;
console.log(resultado);
if (resultado < 89) fibonacci();
}
fibonacci();
Yo lo habia desarrollado en LLP.
Reto de Sucesión de Fibonacci con los 20 primeros números:
function programa(number){
let i=0;
let aux=0
let b=1;
let acumulador=0;
while(i<number){
aux=b;
b=contador;
contador=aux+b;
i=i+1;
console.log(c);
}
}
programa(7);
Reto Fibonacci en Python
numbers = []
def fibonacci(n):
for i in range(n):
if i == 0:
numbers.append(i)
elif i == 1:
numbers.append(i)
else:
numbers.append(numbers[i-1] + numbers[i-2])
return numbers
print(fibonacci(8))
Resultado: [0, 1, 1, 2, 3, 5, 8, 13]
Algoritmo fibonacci en Java
gvoscar_
public class Fibonacci {
//función recursiva
public static int fib(int n) {
if (n > 1) {
return fib(n - 1) + fib(n - 2);
} else if (n == 1) {
// caso base
return 1;
} else if (n == 0) {
// caso base
return 0;
} else {
//error
System.out.println("Tamaño < 1");
return -1;
}
}
public static void showFib(int n) {
System.out.println("Fibonacci de " + n);
for (int i = 0; i < n; i++) {
System.out.print(fib(i) + " ");
}
}
public static void main(String[] args) {
showFib(10);
}
}
RESULTADO:
Fibonacci de tamaño 10
0 1 1 2 3 5 8 13 21 34
Process finished with exit code 0
El diagrama de Fibonacci en JavaScript:
n va a ser la cantidad de numeros de la serie que se ejecutara.
var fib0=0;
var fib1=1;
var temp;
for(var n=8;n>0;n--){
if(n>0){
temp=fib0;
fib0=fib1
fib1=fib1+temp;
result=fib1;
}
else{
result=fib0;
}
console.log(result);
}
Este es el reto desarrollado en Python, empleé la recursividad para resolverlo.
def fibo(n):
if n <= 1:
return n
return fibo(n-1) + fibo(n-2)
if __name__ == '__main__':
print(fibo(8))
>>> 21
En este video se habla de la programación estructura y pide como reto dejar algoritmo fibonacci por lo que a continuación lo pongo en lenguaje python:
from math import sqrt
def F(n):
return ((1+sqrt(5))**n-(1-sqrt(5))n)/(2n*sqrt(5))
def Fibonacci(startNumber, endNumber):
n = 0
cur = F(n)
while cur <= endNumber:
if startNumber <= cur:
print(cur)
n += 1
cur = F(n)
Fibonacci(1,100)
Salida
1.0
1.0
2.0
3.0000000000000004
5.000000000000001
8.000000000000002
13.000000000000002
21.000000000000004
34.00000000000001
55.000000000000014
89.00000000000003
La función Fibonacci() calcula el número de Fibonacci en alguna posición en una secuencia especificada por el número inicial y final.
Aqui hay un ejemplo que encontre en un repositorio de github.
Encantado de aprender.
function fibonacci(number)
{
let
a = 1;
b = 0;
s, c = 1;
console.log (a +b);
for ( i = 3; i <= number; i++)
{
c = a+ b;
console.log (c);
s = s + c;
a = b;
b = c;
}
}
fibonacci( prompt() )
Ejemplo del algoritmo Fibonacci
int fibonacci(int n)
{
if (n>1){
return fibonacci(n-1) + fibonacci(n-2); //función recursiva
}
else if (n1) { // caso base
return 1;
}
else if (n0){ // caso base
return 0;
}
else{ //error
System.out.println(“Debes ingresar un tamaño mayor o igual a 1”);
return -1;
}
}
Cumpliendo el reto de Fibonacci
JAVA
public static void main(String[] args) {
// TODO code application logic here
int fibo0int = 0;
int fibo1int = 1;
String resultadoStr = fibo0int + " , "+fibo1int;
for(int i = 0; i < 8; i++){
int temp = fibo0int;
fibo0int = fibo1int;
fibo1int = fibo1int + temp;
resultadoStr = resultadoStr + " , "+fibo1int;
}
System.out.println(resultadoStr);
}
Reto en JavaScript:
function fibonacci (index) {
let acc = 1;
let previous = 0;
let next = 1;
let result = 1;
if (!index) return 0;
while (acc <= index) {
result = previous + next;
previous = next;
next = result;
acc++;
}
return next;
}
console.log(`\nResult: ${fibonacci(1)}`);
Challenged accepted in Javascript
const n = prompt("Ingrese la cantidad de valores Fibonacci que desea conocer");
function fibonacci(){
const f0 = 0;
const f1 = 1;
const fn = n-1 + n-2;
for (let i = 1; i <= n; i++) {
console.log(fn);
}
}
fibonacci();
Este es el ejercicio con c#
namespace fibonachi
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("ingresa un numero: ");
int n = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("valor ingresado: " + n);
int a = 0;
int b = 1;
int r = 0;
while (n > 0)
{
int result = a;
a = b;
b = b + result;
n--;
r = result;
}
Console.WriteLine("el resultado es: " + r);
Console.ReadLine();
}
}
}
La programación estructurada se define como una técnica para escribir lenguajes de programación que permite sólo el uso de tres tipos de sentencias o estructuras de control: Sentencias secuenciales. Sentencias selectivas (condicionales). Sentencias repetitivas (iteraciones o bucles).
La programación estructurada es una teoría orientada a mejorar la claridad, calidad y tiempo de desarrollo utilizando únicamente subrutinas o funciones. Basada en el teorema del programa estructurado propuesto por Böhm y Jacopini, ha permitido desarrollar software de fácil comprensión.
Bueno yo no se si lo entendi bien, pero aca lo dejo en Js:
let n = 8;
let fib0 = 0;
let fib1 = 1;
let result;
let temp;
for (let i = 0; i <= 8; i ++){
temp = fib0;
fib0 = fib1;
fib1 = fib1 + temp;
if (n > 0){
n = n - 1;
console.log("This is: " + n); //0
} else {
result = fib0;
console.log("Now the result is: " + result); // 34
}
};
En Java con un ciclo for
import java.util.Scanner;
public class Fibo {
public static void main(String[] args) {
Scanner teclado = new Scanner(System.in);
int fib0 = 0;
int fib1 = 1;
System.out.println("Por favor ingresa el valor de" +
" la secuencia que quieres calcular");
int n = teclado.nextInt();
for (int i = n; i > 0 ; i-- ) {
int temp = fib0;
fib0 = fib1;
fib1 = fib1 + temp;
}
System.out.println("El resultado es: " + fib0);
}
}
Mi codigo de la secuencia
let count = 0;
function fibonacci(n) {
let n1 = 0;
let n2 = 1;
console.log(n1)
console.log(n2)
while (count < n) {
let result = n1 + n2;
console.log(result)
n1 = n2;
n2 = result;
count++;
}
}
fibonacci(15);
Algoritmo Fibonacci en C#
made with python
n=8
fib0=0
fib1=1
while n>0:
temp = fib0
fib0 = fib1
fib1 = fib1 + temp
n = n - 1
print(fib0)
Reto de Fibo hecho en C++
Lo hice JS y HTML. La verdad es algo bastante simple y arcaico xd no le puse ningún estilo
Solución en python
def fibonacci(number):
fib0 = 0
fib1= 1
while number > 0:
temp = fib0
fib0 = fib1
fib1 += temp
number -= 1
print(fib0)
fibonacci(number)
using System;
public class Program
{
public static void Main()
{
int n, fb0 = 0, fb1 = 1, siguiente;
Console.Write("Digite el valor de n: ");
n = Convert.ToInt32(Console.ReadLine());
for (int i = 0; i <= n; i++)
{
if (i <= 1)
{
siguiente = i;
}
else
{
siguiente = fb0 + fb1;
fb0 = fb1;
fb1 = siguiente;
}
Console.WriteLine(siguiente);
}
}
}
Reto Secuencia Fibonacci en Python:
Usando Python
fx = int(input("Digite fx: "))
serie = [0,1]
contador = 1
resultado = 0
while(contador < fx):
contador += 1
resultado = serie[len(serie) - 1] + serie[len(serie) - 2]
serie.append(resultado)
print (f"Fx en la posicion {fx} es {serie[-1]}")
Usando JAVA
package rfibonacci;
import java.util.Scanner;
public class Rfibonacci {
public static void main(String[] args){
int n, temp, fib0, fib1;
Scanner lector = new Scanner(System.in);
System.out.println("Ingresar un numero entero");
n = Integer.parseInt(lector.nextLine());
temp = 0;
fib0 = 0;
fib1 = 1;
while(n > 0){
temp=fib0;
fib0=fib1;
fib1= fib1 + temp;
n = n-1;
}
System.out.println("Resultado: " + fib0);
}
}
Escrito en C
Este es mi reto, hecho en el lenguaje C
#include <stdio.h>
int main()
{
unsigned int numeroAnterior1, numeroAnterior2, numeroActual;
numeroAnterior1 = numeroActual = 0;
numeroAnterior2 = 1;
for (int i = 0; i < 10; i++) {
printf("%i ", numeroActual);
numeroActual = numeroAnterior1 + numeroAnterior2;
numeroAnterior1 = numeroAnterior2;
numeroAnterior2 = numeroActual;
}
return 0;
}
Encontré esto, que puede servir de ejemplo:
//N primeros términos de la serie de fibonacci
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
int numero, fibo1, fibo2, i;
do
{
cout << "Introduce numero mayor que 1: ";
cin >> numero;
} while(numero <= 1);
cout << endl;
cout << "Los " << numero << " primeros numeros de la serie de Fibonacci son:" << endl;
fibo1=1;
fibo2=1;
cout << fibo1 << " ";
for(i = 2; i <= numero; i++)
{
cout << fibo2 << " ";
fibo2 = fibo1 + fibo2;
fibo1 = fibo2 - fibo1;
}
cout << endl << endl;
system("pause");
}
Con javascript:
function fibo(numero){
let fb0 = 0;
let fb1 = 1;
let result = 0;
for(let i = n; i >=0; i--){
result =fb0;
console.log(result)
fb0 = fb1;
fb1 = result + fb0;
}
}
Resuelto usando recursividad con Java.
en JAVA podria ser asi:
public static int fibonacci(int N){
int aux = 0;
if (N ==1 || N==2){
aux = 1; }
else{
aux = fibonacci(N-1) + fibonacci(N-2); }
return aux;}
Gracias!!
PROGRAMA EN TURBO PASCAL 7.0
program fibonacci;
uses crt;
var
n, fib0, fib1, temp, result : integer;
begin
n := 8;
fib0 := 0;
fib1 := 1;
while (n > 0) do
begin
temp := fib0;
fib0 := fib1;
fib1 := fib1 + temp;
n := n-1;
end;
result := fib0;
writeln( " el resultado es: ", result)
end.
<
function fibonacci(numero)
{
let numeros=[0,1];
for (let i = 2; i < numero; i++) {
numeros[i] = numeros[i - 2] + numeros[i - 1];
}
return numeros;
}
document.write(fibonacci(10));
>
package main
import "fmt"
func main() {
fmt.Println(fibonacci(8))
}
func fibonacci(n int) int {
var ni int = n
var fib0 int = 0
var fib1 int = 1
for ni > 0 {
temp := fib0
fib0 = fib1
fib1 = fib1 + temp
ni = ni - 1
}
return fib0
}
Javascript:
/**
* Function to create a Fibonacci series
* @param {number} n Fibonacci number
*/
function Fibonacci(n){
debugger;
let fb0 = 0,fb1 = 1,result = 0;
while (n > 0){
var temp = fb0;
fb0 = fb1;
fb1 = fb0 + temp;
result = fb0;
n -=1;
}
return result;
}
console.log(Fibonacci(6))
Para aquellos que estén comenzando a programar les dejo mi programa en C con comentarios para que les sirva de guía.
public class Fibonacci{
public static void main(String[] args) {
int serie = 15, num1 = 0, num2 = 1, suma = 1;
System.out.println(num1);
for (int i = 1; i < serie; i++) {
System.out.println(suma);
suma = num1 + num2;
num1 = num2;
num2 = suma;
}
}
}
muchas gracias he usado sus aporte en mis apuntes
¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.