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
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
La programación estructurada apareció como solución a la programación con escritura secuencial, la cual era muy difícil y costosa de leer, mantener y modificar. La programación estructurada nace con la arquitectura de Von Neuman, la cual reconoce que tanto los programas como los datos que estos arrojan pueden guardarse en memoria.
A partir de la arquitectura de Von Neumann se crean las estructuras de control, que son la base de la programación estructurada. Con la aparición de las estructuras de control se redujo la necesidad de usar la expresión “GOTO”, que se refiere a llamar una línea de código cualquiera desde otra línea de código. A continuación vemos un ejemplo de un diagrama de flujo estructurado que implementa la serie de Fibonacci.
Algunos de los primeros lenguajes que implementaron la programación estructurada son FORTRAN, Pascal, COBOL, ADA, Perl y C.
La programación estructurada se caracteriza por el uso de estructuras de control (condicionales y ciclos). Otras características de la programación estructurada (y de los lenguajes imperativos en general) son:
Contribución creada por: Ciro Villafraz.
Aportes 168
Preguntas 3
Este lo hice en cobol (programación estructurada):
Aquí está el reto de la serie de Fibonacci hecho en Python.
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);
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:
Programación estructurada
Características del lenguaje imperativo
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;
}
Secuencia de Fibonacci en Python
Antes de programar es bueno crear tu diagrama de secuencia para comprender el flujo del programa a desarrollar.
Les comparto mi codigo del reto.
recuerdo en la secundaria, las primeras líneas en C
Pondré uno en JS porque quiero ser popular…
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.
💙 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;
}
}
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()
Ejercicio en Python:
n = 8
fib0 = 0
fib1 = 1
while n > 0:
temp = fib0
fib0 = fib1
fib1 += temp
n -= 1
print(fib0)
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.
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);
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
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
Aqui dejo el algoritmo del diagrama de flujo en PHP:
<?php
function fibonacci($n) {
$fib0 = 0;
$fib1 = 1;
while($n > 0) {
echo $fib0 . "<br>";
$temp = $fib0;
$fib0 = $fib1;
$fib1 += $temp;
$n--;
}
}
fibonacci(8);
Simple
let n = 8;
let fib0 = 0;
let fib1 = 1;
if (n > 0) {
let temp = fib0
fib0 = fib1
fib1 = fib1 + temp
n--
} else {
let result = fib0
console.log(result);
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)
Vi a alguien en Cobol, yo también quiero ser cool😎
Este está hecho en Assembly (NASM + gcc
muestra los n primieros numeros de la serie
;assemble: -->> nasm -f win64 -o fibo.o fibo.asm -l fibo.lst
;link: -->> gcc -o fibo fibo.o
;run: -->> fibo
extern printf, scanf
segment .data
fmt db "%d, ", 0
segment .bss
n resq 1
segment .text
global main
main:
sub rsp, 0x20
mov rcx, fmt
mov rdx, n
call scanf
xor r12, r12
mov r13, 1
cmp dword[n], 1
jl finciclo
mov rcx, fmt
mov rdx, 1
call printf
ciclo:
cmp dword[n], 1
jle finciclo
mov rbx, r12
mov r12, r13
add r13, rbx
mov rcx, fmt
mov rdx, r13
call printf
dec dword[n]
jmp ciclo
finciclo:
add rsp, 0x20
ret
El reto de fibonacci escrito en Pascal
Es la implementaci[on del diagrama de flujo
function fibo(n: longword): longword;
var fib0, fib1, temp: longword;
begin
fib0 := 0;
fib1 := 1;
while n > 0 do begin
temp := fib0;
fib0 := fib1;
fib1 := fib1 + temp;
n := n - 1;
end;
exit(fib0);
end;
#include <iostream>
using namespace std;
int main(){
int n=8;
int fib0=0;
int fib1=1;
int temp;
int result;
while (n>0)
{
temp=fib0;
fib0=fib1;
fib1=fib1+temp;
cout<<temp;
n=n-1;
}
result=fib0;
}
Hace rato no hacía estos ejercicios, pero así me quedó. Bastante parecido
var control = 0;
var fib0 = 0;
console.log(fib0);
var fib1 = 1;
console.log(fib1);
var fib2 = 1;
console.log(fib2);
while(control < 10){
control++;
fib0 = fib1;
fib1 = fib2;
fib2 = fib0 + fib1;
console.log(fib2);
}
Hecho en java
Para aquellos que estén comenzando a programar les dejo mi programa en C con comentarios para que les sirva de guía.
Mi solucion al reto en Python
def fibonacci(n, a=None, b=None):
if a is None or b is None:
a, b = 0, 1
result = a + b
print(f'n: {n}; resultado: {result}')
if n > 1:
n -= 1
return fibonacci(n, b, result)
else: return
if __name__ == '__main__':
fibonacci(8)
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();
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 ]
let n = 8
let fib0 = 0
let fib1 = 1
function fibonacci ()
{
while (n > 0)
{
let temp = fib0
fib0 = fib1
fib1 = fib1 + temp
n = n - 1
console.log(fib0)
}
}
fibonacci()
Esto de programacion estructurada me parece un poco avanzada a mi gusto. El reto del profe hice lo que pude pero no se si lo entenderan.
function secuenciaFinobacci(num){
let a = 0, b = 1
for (let i = 1; i <= num; i++) {
let numero = a + b
a = b
b = numero
console.log(numero)
}
}
secuenciaFinobacci(5)
 {
if(i < 1) {
console.log(x);
console.log(y);
}
x = x + y;
console.log(x);
y = y + x;
console.log(y);
}
Aqui les dejo el reto en Java realizado de dos maneras, primero Imperativo y después Declarativo.
import java.util.Scanner;
public class Imperative {
public static void main(String[] args) {
System.out.print("Please enter a number: ");
Scanner sc = new Scanner(System.in);
String number = sc.nextLine();
Integer num = null;
if(number.matches("^\\d+$")){
num = Integer.parseInt(number);
}else{
System.out.println("You did not enter a number.");
}
if(num != null && num > 0){
int fib0 = 0;
int fib1;
if(num == 1){
fib1 = 0;
}else if(num == 2){
fib1 = 1;
}else{
num -= 2;
fib1 = 1;
while(num > 0){
int temp = fib0;
fib0 = fib1;
fib1 += temp;
num--;
}
}
System.out.println("The number you enter is the number " + fib1 + " in the Fibonacci sequence.");
}else{
System.out.println("The result is 0");
}
}
import java.util.Scanner;
public class Declarative {
public static void main(String[] args) {
System.out.print("Please enter a number: ");
Scanner sc = new Scanner(System.in);
String number = sc.nextLine();
Integer num = null;
if(number.matches("^\\d+$")){
num = Integer.parseInt(number);
}else{
System.out.println("You did not enter a number.");
}
System.out.println("The number you enter is the number " + FibonacciPosition(num) + " in the Fibonacci sequence.");
}
private static Integer FibonacciPosition(Integer num) {
int a0 = 0;
int a1 = 1;
int res = -1;
if(num > 0) res = (num == 1) ? a0 : num == 2 ? a1 : FibonacciPosition(num-2) + FibonacciPosition(num-1);
return res;
}
}
Se puede ver que de forma Declarativa se hace uso de la recursividad y de otras herramientas del lenguaje que lo hacen más difícil de leer pero que reducen las líneas de código.
✅
Algoritmo Fibonacci realizado en Javascript siguiendo al pie de la letra el diagrama de flujo
Sin duda el diagrama de flujo te hace la vida más fácil sobre todo si estás empezando a desarrollar esa lógica de programación
Aqui dejo el algoritmo del diagrama de flujo en Java:
class FibonacciEstructurada {
public static void main(String args[]) {
FibonacciEstructurada f = new FibonacciEstructurada();
f.fibonacci(8);
}
private void fibonacci(int n) {
int fib0 = 0;
int fib1 = 1;
while(n > 0) {
System.out.println(fib0);
int temp = fib0;
fib0 = fib1;
fib1 += temp;
n--;
}
}
}
Mi programa en Javascript ejecutado desde WSL Ubuntu
Bueno aquí he podido resolver el Algoritmo de Fibonacci (con Javascript) de dos maneras distintas. La primera es la forma mas sencilla de implementarlo:
Ahora por otro lado, también lo desarrolle de una manera mas detallada y extensa, por si a alguien se le dificulta entenderlo, implementarlo o ambas:
Y bueno, para quien quiera probarlo y correrlo, aquí le dejo ambas implementaciones de la Serie de Fibonacci
Saludos! 👍👍
Mi solución de la serie de Fibonacci usando la programación recursiva
genera los primeros dígitos que le indiques de la serie Fibonacci
e.g.
ingrese un numero: 15
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]
Se realizaron dos funciones que reciben un parámetro n
que representa cuantos números de la secuencia necesito:
String
donde cada elemento de la secuencia esta separado por un espacio.ArrayList
donde cada posición en la lista es un número de la secuencia (Aunque al mostrarlo en pantalla, se mapea para mostrarlo en consola).import java.util.ArrayList;
import java.util.stream.Collectors;
public class Fibonacci
{
public static void main(String[] args)
{
Fibonacci fibo = new Fibonacci();
String resultStr = fibo.getStringSequenceUntil(2);
// Map the arraylist to string
String resultArr = fibo.getListSequenceUntil(7).stream().map(Object::toString).collect(Collectors.joining(" "));
System.out.println(String.format("Fibonacci (String): %s\nFibonacci (ArrayList): %s\n", resultStr, resultArr));
}
/**
* Get a string with N numbers from Fibonacci sequence.
*
* @param int How numbers you need in the sequence
* @return String with N numbers separated with a spaces
*/
public String getStringSequenceUntil(int n)
{
// Return a default response to invalid cases
if (n <= 0)
{
return "";
}
String result = "0";
Long n1 = 0L, n2 = 1L, n3 = 1L;
// Generate N numbers from fibonacci
for(int i=1; i<n; i++)
{
result += " " + n3.toString();
n3 = n1 + n2;
n1 = n2;
n2 = n3;
}
return result;
}
/**
* Get an arraylist with N numbers from Fibonacci sequence.
*
* @param int How numbers you need in the sequence
* @return List with N numbers separated with a spaces
*/
public ArrayList<Long> getListSequenceUntil(int n)
{
ArrayList<Long> result = new ArrayList<Long>();
// Return a default response to invalid cases
if (n <= 0)
{
return result;
}
Long n1 = 0L, n2 = 1L, n3 = 1L;
result.add(0L);
// Generate N numbers from fibonacci
for(int i=1; i<n; i++)
{
result.add(n3);
n3 = n1 + n2;
n1 = n2;
n2 = n3;
}
return result;
}
}
Para ejecutarlo en terminal:
javac Fibonacci.java
java Fibonacci
Retorna el siguiente resultado:
Fibonacci (String): 0 1
Fibonacci (ArrayList): 0 1 1 2 3 5 8
La serie de fibonacci en Python:
n = int(input("Ingresa una cantidad de términos: "))
terminos_encontrados = 2
n1 = 1
n2 = 1
print(n1)
print(n2)
while terminos_encontrados < n:
calculado = n1 + n2
print(calculado)
terminos_encontrados += 1
n1 = n2
n2 = calculado
Lo he hecho en Typescript ( javascript tipado)
function fibonacci(n: number): number {
if (n <= 0) {
return 0;
} else if (n === 1) {
return 1;
} else {
let a = 0;
let b = 1;
let result = 0;
for (let i = 2; i <= n; i++) {
result = a + b;
a = b;
b = result;
}
return result;
}
}
// Ejemplo de uso:
console.log(fibonacci(0)); // 0
console.log(fibonacci(1)); // 1
console.log(fibonacci(2)); // 1
console.log(fibonacci(5)); // 5
console.log(fibonacci(10)); // 55
De acuerdo a las características:
_- Se espera que tenga de entrada y salida un numero
Qué bueno saber lo del GOTO y por qué nace la estructurada. Buenos datos 🤓
en python utilizando recursividad:
def Fib(n):
if n <= 0:
return 0
elif n == 1:
return 1
else:
return Fib(n-1) + Fib(n-2)
n = int(input('How many number you want in this series: '))
print(f'The fibonacci series of {n} is =>', end=' ')
for n in range(n + 1):
print(f'{Fib(n)}', end=' ')
print('\n')
En el siempre olvidado FORTRAN; imprime los primeros 10, aunque claro que se puede agregar el condicional para que se pregunte el número particular a calcular
PROGRAM fib
IMPLICIT NONE
INTEGER :: i, fib0, fib1, tmp
fib0 = 0; fib1 = 1
DO i = 1, 10
tmp = fib0
fib0 = fib1
fib1 = fib1 + tmp
WRITE(*,*) fib1
ENDDO
END PROGRAM
JS
let num1 = 0;
let num2 = 1;
for (let i = 0; i < 10; i++)
{
console.log(num1)
let numFi = num1 + num2
num1 = num2
num2 = numFi
}
Aquí esta el código en python
def Fibonacci():
a = 0
b = 1
x = 1
while x<=100:
print(a)
c=a+b
a=b
b=c
x=x+1
if __name__ == "__main__":
fibonacci()
Recuerdo que en el cusro de Lenguaje C mencina que el uso de goto es una mala practica y que ya esta en desuso.
Este es el ejemplo con el lenguaje de programación gráfica LabVIEW
Compañeros les comparto como en JavaScript hice el algoritmo Fibonacci
number = int(input("Cuantas iteraciones "))
def fibonacci(number):
fib0 = 0
fib1= 1
lista_fibo =[]
while number > 0:
temp = fib0
fib0 = fib1
fib1 += temp
number -= 1
lista_fibo.append(fib0)
print(fib0)
print(lista_fibo)
fibonacci(number)
Mi solución del reto en JavaScript
let fib0 = 0, fib1 = 1, temp
function fibonacci(n) {
while(n > 0) {
temp = fib0
fib0 = fib1
fib1 = fib1 + temp
n = n - 1
}
return fib0
}
fibonacci(10)
let n = 10;
let fb0 = 0;
let fb1 = 1;
let result
for (let index = 0; index <= n; index++) {
if (index > 0) {
let temp = fb0;
fb0 = fb1;
fb1 = fb1 + temp;
index = index * 1
result = temp
}
console.log(result);
}
Mi código en Python
#Algoritmo de finonacci
def finobacci(n):
fib0=0
fib1=1
resultado=0
if(n<=0):
resultado=fib0
else:
for i in range (1,n-1):
temp=fib0
fib0=fib1
fib1=fib1+temp
resultado=fib1
return resultado
print("-- Ahora vamos a ejecutar el algoritmo de Fibonacci --")
print(" Por favor indica para que rango se ejecutara el algorito")
n= int(input("Digita el valor: "))
print(finobacci(n))
Mi solucion ne Python
def fibonacci(num):
a,b = 0,1
lista = list()
for i in range(num):
if b > num: return lista
else:
lista.append(b)
a,b = b, a + b
print(fibonacci(13))
mi solucion:
<function fibonacci(n){
let a = 0
let b = 1
let result = 0
console.log(a)
console.log(b)
for(let i = 0; i < n; i++){
result = a + b
a = b
b = result
console.log(result)
}
}
fibonacci(20)>
Secuencia Fibonacci en Python
En Python, la secuencia Fibonacci se puede implementar usando un ciclo y una tupla. El código a continuación muestra una implementación básica de la secuencia de Fibonacci:
def fibonacci(n):
a, b = 0, 1
for i in range(n):
a, b = b, a + b
return a
print(fibonacci(10))
Este código imprimirá el décimo número de la secuencia de Fibonacci, que es 55.
Secuencia Fibonacci en Haskell
En Haskell, la secuencia Fibonacci se puede implementar usando una función recursiva. El código a continuación muestra una implementación básica de la secuencia de Fibonacci:
fibonacci :: Int -> Int
fibonacci 0 = 0
fibonacci 1 = 1
fibonacci n = fibonacci (n-1) + fibonacci (n-2)
main = print (fibonacci 10)
Secuencia Fibonacci en JavaScript
En JavaScript, la secuencia Fibonacci se puede implementar usando una función recursiva. El código a continuación muestra una implementación básica de la secuencia de Fibonacci:
function fibonacci(n) {
if (n <= 1) {
return n;
} else {
return fibonacci(n - 1) + fibonacci(n - 2);
}
}
console.log(fibonacci(10));
Este programa esta hecho en Java y muestra la sucesión de fibonacci hasta la posición 92 ya que es lo máximo que permite el tipo de dato long en Java
public class Main {
public static void main(String[] args) {
//Programa que genere infinitos numero de la sucesión de fibonacci
//Este programa esta optimizado actualmente solo para mostrar hasta la posicion 92 de la sucesion, ya que es lo
//que permite el tipo de dato long en Java
long fib0 = 0l, fib1 = 1, result = 0, first = 0, second = 0, n = 0;
result = fib1 + fib0;
System.out.println("Fib Pos # " + n + " " + fib0);
n++;
System.out.println("Fib Pos # " + n + " " + fib1);
n++;
System.out.println("Fib Pos # " + n + " " + result);
while (n < 92) {
n++;
second = result;
first = fib1;
result = second + first;
fib1 = second;
System.out.println("Fib Pos # " + n + " " + result);
}
}
}
Los 10 primeros números de Fibonacci en Java
public class firstclass {
public static void main(String[] args) {
int n1 = 0, n2 = 1, n3, limite = 10;
System.out.print(n1 + " " + n2);
for (int i = 2; i < limite; ++i) {
n3 = n1 + n2;
System.out.print(" " + n3);
n1 = n2;
n2 = n3;
}
}
}
.
Este algoritmo utiliza recursión para calcular el n-ésimo número de la serie de Fibonacci. Cada vez que se llama a la función con un número n, se comprueba si n es menor o igual a 2. Si es así, se devuelve 1. Si no, se devuelve la suma de la llamada recursiva a la función con (n-1) y (n-2).
<code>function fibonacci(n) {
if (n <= 2) return 1;
return fibonacci(n-1) + fibonacci(n-2);
}
<code>
def fibonacci(n):
a=0;
b=1;
result=0
arr= [0,1]
for i in range(n-1):
result=a+b
a=b
b=result
arr.append(result)
return arr
print(fibonacci(5))
Solucion del reto
f0=0
f1=1
fn=0
print(f0)
while fn<55:
f0=f1
f1=fn
fn= f0+f1
print(fn)```
Otro gran ejercicio, más allá de implementar nuestro propio algoritmo de fibonacci, es perderse un rato en los comentarios y leer y entender los algoritmos de otras personas, sobre todo, aquellos que están escritos en lenguajes de programación que desconocemos pues nos ayudará a desarrollar nuestra lógica (la secuencialidad no es ajena a ningún lenguaje) y ver que, fundamentalmente, queremos decir lo mismo solo que de maneras diferentes.
Mi Fibonacci con JS
const fib =(num)=>{
let arr = [1,2]
for(let i = 2; i<num; i++){
arr[i] = (arr[i-1]) + (arr[i-2])
}
}
Dejo un pequeño aporte para que vean de donde se deriva cada paradigma.
Así hice Fibonacci en JS
En resumen:
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.
wow que recuerdos, estudie cobol, pascal y basic hace 25 años y ya no recuerdo mucho, pero fue mi motivacion para volver a aprender. me encanta toda la historia ya que me trae gratos recuerdos…gracias a su curso profe hector vega conoci al profe carSantello voy por sus cursos al finalizar este…
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?