No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Programaci贸n estructurada

6/21
Recursos

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.

Arquitectura de Von Neumann

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 鈥淕OTO鈥, 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.
Fibonacci

Algunos de los primeros lenguajes que implementaron la programaci贸n estructurada son FORTRAN, Pascal, COBOL, ADA, Perl y C.

Caracter铆sticas de la programaci贸n estructurada

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:

  • Uso de entradas/salidas (input y output, o I/O)
  • Manejo de errores y excepciones.
  • Abstracci贸n de procedimientos.
  • Expresiones y asignaci贸n.
  • Soporte para estructuras de datos.

Contribuci贸n creada por: Ciro Villafraz.

Aportes 150

Preguntas 3

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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);

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:

  • Unidad de control: Se encargan de las etapas de captaci贸n y decodificaci贸n de una instrucci贸n
  • Unidad l贸gica-aritm茅tica o ALU: Se encarga de realizar operaciones matem谩ticas y de l贸gica
  • Memoria: D贸nde se almacena nuestro programa
  • Dispositivo de entrada: Los datos de entrada
  • Dispositivo de salida: Salida de datos

Solucion al reto de la secuencia Fibonacci, escrito en JavaScript 馃榾

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);

Programaci贸n estructurada

  • Aparece luego del paradigma de la programaci贸n con escritura secuencial
  • La escritura secuencial era muy dif铆cil y costosa de leer, mantener y modificar
  • En 1968 Dijkstra llam贸 la atenci贸n sobre el da帽o de la expresi贸n 鈥淕OTO鈥
  • Con la arquitectura de Von Neumann se reconoce que tanto los programas como los datos que estos arrojan pueden residir en la misma computadora
  • Usa estructuras de control (while, for, dowhile)

Caracter铆sticas del lenguaje imperativo

  • Estructuras de control
  • Entradas/Salidas
  • Manejo de errores y excepciones
  • Abstraccion de procedimientos
  • Expresiones y asignaci贸n
  • Soporte para estructuras de datos

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鈥檚 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 ]

Hiii, Dear @PlartziTeam. This is my Fibonnaci C code bellow. ![](https://static.platzi.com/media/user_upload/image-93c1dce1-90a8-4cfb-b8e8-b54912b37c5d.jpg)
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)

![](

Secuencia de Fibonacci en JavaScript:

let fibonacci = 10
let x = 0
let y = 1

for(i = 0; i <= fibonacci; i++) {
  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]

Reto de Fibonacci hecho con Java

Se realizaron dos funciones que reciben un par谩metro n que representa cuantos n煤meros de la secuencia necesito:

  • Retorna un String donde cada elemento de la secuencia esta separado por un espacio.
  • Retorna un 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

  • Se usa una estructura de control iterativa, ciclo for
  • Se realiza la expresi贸n y asignaci贸n en las variables result, a y b
  • Se manejan posibles errores y excepciones. Si es un n煤mero menor a cero, si es igual a 1, etc鈥

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)

Los primeros 10 d铆gitos de la serie Fibonacci


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鈥racias a su curso profe hector vega conoci al profe carSantello voy por sus cursos al finalizar este鈥

Reto completado, lo hice en C++

#include <iostream>

using namespace std;

int main()
{
    int n = 8, fib0 = 0, fib1 = 1, temp = 0, resultado = 0;

    while (n > 0 && n < 1000)
    {
        temp = fib0;
        fib0 = fib1;
        fib1 += temp;
        resultado = fib0;
        cout << resultado << endl;
        n++;
    }
}

C贸digo en JavaScript

//FIBONACCI
let n = 8;
let temp, fib0 = 0;
let fib1 = 1;
while (n > 0) {
  temp = fib0;
  fib0 = fib1;
  fib1 += temp
  n--;
  console.log(temp);
}

Aunque suene raro, Von Neumann se pronuncia Fon Noiman 馃棧

Desaf铆o en JS:

function fibonacci(n){
    let fib0 = 0; let fib1 = 1; let temp; let num = n; let sec = 0;
    
    console.log('Secuencia Fibonacci:');
    while (num > 0){
        temp = fib0;
        fib0 = fib1;
        fib1 += temp;
        num -= 1;
        sec += 1;
        console.log(`${sec}: ${fib0}`);
    }
}

fibonacci(8);

/*imprime:
Secuencia Fibonacci:
1: 1
2: 1
3: 2
4: 3
5: 5
6: 8
7: 13
8: 21
9: 34
10: 55
*/

Yo estoy cursando la Escuela de Programaci贸n y Desarrollo de Software y en el contenido aun no vemos ning煤n lenguaje de programaci贸n (solo html y css pero no puedo hacer esto con ello) as铆 es que no podre hacer el reto 馃槮 鈥 Aun as铆 ya tengo mis notas, me voy a la siguiente lecci贸n.

Solucion al reto de la secuencia Fibonacci, escrito en python

import math
t = int(input('Hasta que numero de la serie fibonacci desea conocer? '))
a=0
b=1
c=0
i=2
print ('0')
print ('1')
while (i < t):
  i = i+1
  c=a+b
  print(c)
  a=b
  b=c  

En C, que es un lenguaje procedimental.

#include <stdio.h>

int fib(int n);

int main() {
    printf("%d\n", fib(7));
    return 0;
}

// Solo funciona con n煤meros mayores o iguales a 0
int fib(int n){
    if (n < 2){
        return n;
    }
    return fib(n - 1) + fib(n - 2);
}

Como complemento, se me ocurri贸 esta manera de hacer una funci贸n de Fibonacci:

function fibonacci(iterations) {
  if (iterations === 0) return 0;
  if (iterations === 1) return 1;
  return fibonacci(iterations - 1) + fibonacci(iterations - 2);
}

S茅 que podr铆a optimizarse a煤n m谩s para que no consuma tantos recursos y que no tarde tanto, pero me pareci贸 curiosa esta forma de hacerlo y quise compartirlo. 馃挌

Codigo realizado en Python con concepto de recursividad y otros conceptos vistos en la ruta de aprendizaje de Python

Yo usaba mucho Goto en flash 馃槃

As铆 me qued贸 en C. Acepto comentarios a ver si algo se puede mejorar

#include<stdio.h>
#include<stdlib.h>

int Fibonacci ();
int numSig = 0, num1 = 0, num2 = 1;

int main(void) {
int n;

  printf("驴Cuantas posiciones deseas conocer?: ");
  scanf("%d", &n);

  for (int i = 0; i < n; i++)
  {
  printf("El numero en la posicion %d es: %d\n", i+1, Fibonacci());
  }
  system("pause");
  }

int Fibonacci () {
    num1 = num2;
    num2 = numSig;
    numSig = num1 + num2;
  return numSig;
    }

Reto Fibonacci en Java:

import java.util.Scanner;
class Main {
    public static void main(String[] args) {
        int temp;
        int n = 0;
        int fib0 = 0;
        int fib1 = 1;
        
        Scanner input = new Scanner(System.in);
        
        System.out.println("Digite la cantidad de valores que se van a mostrar y presione enter: ");
        
        for(n = input.nextInt(); n>0; n--){
                temp = fib0;
                fib0 = fib1;
                fib1 += temp;
                System.out.print(fib0+" ");
        }
    }
}

Fibonacci en Python3
.

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

	}

}

Conceptos


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.

Reto


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;
    }
    
}