Introducción a Algoritmos con MATLAB/Octave

Este documento presenta una serie de algoritmos fundamentales implementados en MATLAB o Octave, cubriendo desde operaciones básicas hasta problemas matemáticos y lógicos. Cada sección incluye una descripción del problema, el código fuente y una explicación de los conceptos clave involucrados.

Estructura de los Algoritmos

Cada algoritmo comienza con las instrucciones clear; y clc; para limpiar el espacio de trabajo y la ventana de comandos, respectivamente, asegurando un entorno de ejecución limpio para cada ejercicio.

Algoritmo 1: Impresión Repetida de una Frase

Este algoritmo demuestra el uso de un bucle for para imprimir una frase específica un millón de veces. Es un ejemplo sencillo de iteración y rendimiento básico.

clear;
clc;
for i=1:1:1000000
    disp('ser ingeniero...no es una excusa para...\n');
end

Algoritmo 2: Tabla de Multiplicar

Un algoritmo que solicita al usuario un número entero y luego muestra su tabla de multiplicar del 1 al 10. Utiliza la función input para la entrada de datos y fprintf para un formato de salida claro.

clear;
clc;
x=input('Introducir un número entero: ');
for i=1:10
    fprintf(' %d x %d = %d\n',x,i,x*i);
end

Algoritmo 3: Suma de los N Primeros Números Naturales

Este algoritmo calcula la suma de los primeros N números naturales, donde N es un valor introducido por el usuario. Incluye una validación de entrada para asegurar que N sea un número positivo.

clear;
clc;
x=input('Introduzca el número de enteros que quiere sumar\n ');
if x>0
    suma=0;
    entero=1;
    while entero <= x
        suma=suma+entero;
        entero=entero+1;
    end
    fprintf('El resultado del sumatorio es %d\n',suma);
else
    disp('El número ha de ser mayor que 0');
end

Algoritmo 4: Cálculo del Factorial de un Número

Un algoritmo para determinar el factorial de un número entero dado. Maneja casos especiales como el factorial de 0 y números negativos, demostrando el uso de estructuras condicionales y bucles.

clear;
clc;
x=input('Introduzca el número: ');
if x < 0
    disp('El número no puede ser menor que 0');
else
    if x==0
        disp('El factorial de 0 es: 1');
    else
        fact=1;
        for i=1:x
            fact=fact*i;
        end
        fprintf('El factorial de %d es: %d\n',x,fact);
    end
end

Algoritmo 5: Producto Mediante Sumas Sucesivas

Este algoritmo calcula el producto de dos números enteros utilizando únicamente sumas sucesivas. Es un excelente ejemplo para entender la aritmética fundamental a nivel algorítmico, incluyendo el manejo de números negativos.

clear;
clc;
x=input('Introducir el multiplicando: ');
y=input('Introducir el multiplicador: ');
if x==0 || y==0
    fprintf('El producto de %dx%d es: 0\n',x,y);
else
    prod=0;
    a=abs(y);
    for i=1:a
        prod=prod+x;
    end
    if y>0
        fprintf('El producto de %dx%d es: %d\n',x,y,prod);
    else
        if x>0
            fprintf('El producto de %dx%d es: %d\n',x,y,abs(prod));
        else
            fprintf('El producto de %dx%d es: -%d\n',x,y,prod);
        end
    end
end

Algoritmo 6: División Mediante Restas Sucesivas

Un algoritmo que realiza la división entera de dos números mediante restas sucesivas. Aborda el caso de la división por cero y el cálculo del resto.

clear;
clc;
x=input('Introduzca un dividendo: ');
y=input('Introduzca un divisor: ');
if y==0
    if x==0
        disp('0 dividido por 0 es indeterminado');
    else
        disp('Dividir por 0 es indefinido');
    end
else
    if x==0
        fprintf('La división de %d/%d es: 0\n',x,y);
    else
        div=0;
        a=abs(x);
        b=abs(y);
        while a>=b
            a=a-b;
            div=div+1;
        end
        if (x>0 && y>0)||(x<0 && y<0)
            fprintf('La división de %d/%d es: %d, resto: %d\n',x,y,div,a);
        else
            fprintf('La división de %d/%d es: -%d, resto: %d\n',x,y,a);
        end
    end
end

Algoritmo 7: Potencia Mediante Multiplicaciones

Este algoritmo calcula la potencia de un número (base) elevado a un exponente, utilizando multiplicaciones sucesivas. Considera casos especiales como el exponente cero y exponentes negativos.

clear;
clc;
a=input('Introduzca el número: ');
b=input('Introduzca la potencia: ');
if b==0
    if a==0
        disp('Valor indefinido (0^0)');
    else
        disp('Cualquier número elevado a 0 es 1');
    end
else
    pot=1;
    for i=1:abs(b)
        pot=pot*a;
    end
    if b>0
        fprintf(' %d elevado a %d es %d\n',a,b,pot);
    else
        fprintf(' %d elevado a %d es %4.3f\n',a,b,1/pot);
    end
end

Algoritmo 8: Números Enteros entre A y B (Ascendente)

Un algoritmo que lee dos números enteros, A y B, y muestra por pantalla todos los números enteros comprendidos entre ellos, ordenados de menor a mayor.

clear;
clc;
a=input('Introduzca a: ');
b=input('Introduzca b: ');
if a<b
    for i=a+1:b-1
        fprintf('\t %d\n',i);
    end
else
    for i=b+1:a-1
        fprintf('\t %d\n',i);
    end
end

Algoritmo 9: Números Enteros entre A y B (Descendente)

Similar al anterior, pero este algoritmo muestra los números enteros entre A y B en orden descendente (de mayor a menor).

clear;
clc;
a=input('Introduzca a: ');
b=input('Introduzca b: ');
if a>b
    for i=a-1:-1:b+1
        fprintf('\t%d\n',i);
    end
else
    for i=b-1:-1:a+1
        fprintf('\t%d\n',i);
    end
end

Algoritmo 10: Números Pares hasta 100

Este algoritmo itera a través de los primeros 100 números naturales y muestra por pantalla solo aquellos que son pares, utilizando el operador módulo.

clear;
clc;
for i=1:100
    if rem(i,2)==0
        fprintf('\t %d\n',i);
    end
end

Algoritmo 11: Múltiplos de 3 entre A y B

Un algoritmo que identifica y muestra todos los múltiplos de 3 que se encuentran entre dos números enteros A y B, independientemente de su orden de entrada.

clear;
clc;
a=input('Introduzca a: ');
b=input('Introduzca b: ');
if a<=b
    inc=1;
else
    inc=-1;
end
disp('Múltiplos de 3 comprendidos entre a y b');
for i=a+inc:inc:b-inc
    if rem(i,3)==0
        fprintf('\t%d\n',i);
    end
end

Algoritmo 12: Pares y Media de Impares (hasta 200)

Este algoritmo procesa los primeros 200 números enteros, mostrando los números pares y calculando la media aritmética de los números impares.

clear;
clc;
media=0;
disp('Números comprendidos entre 1 y 200:');
for i=1:200
    if rem(i,2)==0
        fprintf('\t%d\n',i);
    else
        media=media+i;
    end
end
fprintf('La media aritmética de los impares es %4.2f\n',media/100);

Algoritmo 13: Divisores de un Número

Un algoritmo que, dado un número entero, encuentra y muestra todos sus divisores. Se asegura de trabajar con el valor absoluto del número para el cálculo.

clear;
clc;
x=input('Introduzca el número: ');
fprintf('Los divisores de %d son:\n',x);
x_abs=abs(x);
for i=1:x_abs/2
    if rem(x_abs,i)==0
        fprintf('\t%d\n',i);
    end
end
fprintf('\t%d\n',x_abs);

Algoritmo 14: Determinación de Número Primo

Este algoritmo verifica si un número entero introducido por el usuario es un número primo. Incluye validaciones para números no positivos y optimizaciones para la verificación de primalidad.

clear;
clc;
n=input('Introduzca el número: ');
if n <= 0
    fprintf('%d no es un número primo (debe ser positivo)\n',n);
else
    if n==1 || n==2
        fprintf('%d es un número primo\n',n);
    elseif rem(n,2)==0
        fprintf('%d no es un número primo\n',n);
    else
        resto=1;
        i=3;
        while resto>0 && i*i <= n
            resto=rem(n,i);
            i=i+2;
        end
        if resto==0
            fprintf('%d no es un número primo\n',n);
        else
            fprintf('%d es un número primo\n',n);
        end
    end
end

Algoritmo 15: Conteo de Números Positivos y Negativos

Un algoritmo que lee una lista de números (cuya cantidad es definida por el usuario) y cuenta cuántos de ellos son positivos y cuántos son negativos.

clear;
clc;
n=input('¿Cuántos números va a introducir?: ');
while n < 0
    n=input('No puede ser un valor menor que 0. Inténtelo de nuevo: ');
end
neg=0;
pos=0;
for i=1:n
    x=input('Introduzca un número: ');
    if x<0
        neg=neg+1;
    elseif x>0
        pos=pos+1;
    end
end
fprintf('positivos: %d negativos: %d\n',pos,neg);

Algoritmo 16: Números Pares y Múltiplos de Tres, y Suma de No Cumplidores

Este algoritmo solicita un número entero N y luego muestra todos los enteros menores que N que son pares y múltiplos de tres. Además, calcula la suma de los números que no cumplen esta condición.

clear;
clc;
n=input('Introduzca el número entero: ');
suma=0;
if n < 0
    fprintf('El número %d ha de ser mayor que 0\n',n);
else
    for i=n:-1:0
        if rem(i,2)==0 && rem(i,3)==0
            fprintf('%d\n',i);
        else
            suma=suma+1;
        end
    end
    fprintf('La suma de los que no cumplen es: %d\n',suma);
end

Algoritmo 17: Media de Números hasta Cero

Un algoritmo que lee números de forma continua hasta que el usuario introduce un cero. Una vez finalizada la entrada, calcula y muestra la media aritmética de todos los números introducidos (excluyendo el cero final).

clear;
clc;
media=0;
i=0;
n=input('Introduzca un número: ');
while n~=0
    media=media+n;
    i=i+1;
    n=input('Introduzca un número: ');
end
if i==0
    disp('La media es: 0');
else
    fprintf('La media de los %d números es: %4.2f\n',i,media/i);
end

Algoritmo 18: Cinco Primeros Impares Múltiplos de Tres Mayores que N

Este algoritmo encuentra y muestra los cinco primeros números impares que son múltiplos de tres y que, además, son mayores que un número natural N dado por el usuario.

clear;
clc;
n=input('Introduzca el número entero: ');
while n < 0
    n=input('Introduzca de nuevo [n>0]: ');
end
fprintf('Cinco primeros impares múltiplos de 3 mayores que %d:\n',n);
if rem(n,2)==0
    n=n+1;
else
    n=n+2;
end
contador=0;
while contador < 5
    if rem(n,3)==0
        contador=contador+1;
        fprintf('\t%d\n',n);
    end
    n=n+2;
end

Algoritmo 19: Serie de Fibonacci

Un algoritmo para generar los N primeros elementos de la serie de Fibonacci, donde F1 = 1 y F2 = 1, y cada término subsiguiente es la suma de los dos anteriores (Fi = Fi-1 + Fi-2).

clear;
clc;
x=input('Introduzca el número de elementos en la serie que se desea obtener: ');
if x < 0
    disp('El número ha de ser mayor que 0');
elseif x==1
    disp('El elemento 1 de la serie de Fibonacci es 1');
elseif x==2
    disp('El elemento 1 de la serie de Fibonacci es 1');
    disp('El elemento 2 de la serie de Fibonacci es 1');
else
    a=1; b=1;
    disp('El elemento 1 de la serie de Fibonacci es 1');
    disp('El elemento 2 de la serie de Fibonacci es 1');
    for i=3:x
        f=a+b;
        a=b;
        b=f;
        fprintf('El elemento %d de la serie de Fibonacci es %d\n',i,f);
    end
end

Algoritmo 20: Sucesión 1/N!

Este algoritmo genera los N primeros términos de la sucesión 1, 1/2!, 1/3!, 1/4!, …, 1/N!, calculando el factorial en cada paso.

clear;
clc;
n=input('Introduzca el número de elementos de la serie a calcular: ');
if n < 0
    disp('El número no puede ser menor que 0');
else
    fprintf('La sucesión de %d es: ',n);
    if n==0
        fprintf('1');
    else
        fact=1;
        for i=1:n
            fact=fact*i;
            fprintf('%4.3f,',1/fact);
        end
    end
    fprintf('\n');
end

Algoritmo 21: Aproximación del Exponencial (e^x)

Un algoritmo que calcula una aproximación del exponencial de un número (e^x) utilizando los primeros 20 términos de su serie de Taylor.

clear;
clc;
x=input('Introduzca el número: ');
if x==0
    disp('e elevado a 0 es 1');
else
    suma=1;
    fact=1;
    pot=1;
    for i=1:20
        pot=pot*x;
        fact=fact*i;
        suma=suma+pot/fact;
    end
    fprintf('e elevado a %d es aproximadamente %4.2f\n',x,suma);
end

Algoritmo 22: Cálculo de Ecuación con Sumatoria y Productoria

Este algoritmo calcula el valor de una expresión matemática que incluye una sumatoria y una productoria, basándose en valores de entrada ‘a’ y ‘b’ proporcionados por el usuario.

clear;
clc;
a=input('Introduzca el número a: ');
b=input('Introduzca el número b: ');
if a < 0 || b < 0
    disp('Los números no pueden ser menores que 0');
else
    x_sum=0;
    y_prod=1;
    for i=1:a
        x_sum=x_sum+i*i;
    end
    for j=1:b
        y_prod=y_prod*(j+3);
    end
    fprintf('El valor de la ecuación para a=%d y b=%d es %4.2f\n',a,b,x_sum/y_prod);
end

Algoritmo 23: Reloj Digital 24 Horas

Un algoritmo que simula un reloj digital en formato de 24 horas, mostrando horas, minutos y segundos de forma continua e indefinida.

clear;
clc;
s=0;
m=0;
h=0;
while true
    s=s+1;
    if s>59
        s=0;
        m=m+1;
        if m>59
            h=h+1;
            m=0;
            if h>23
                h=0;
            end
        end
    end
    clc;
    fprintf('%02d:%02d:%02d\n',h,m,s);
    pause(1);
end

Algoritmo 24: Patrón Numérico en Pirámide

Este algoritmo genera un patrón numérico en forma de pirámide, donde cada fila muestra una secuencia de números que se incrementan y luego decrementan, utilizando el operador módulo para los dígitos.

clear;
clc;
for i=1:10
    for j=1:10-i
        fprintf(' ');
    end
    x=i;
    for l=1:i
        fprintf('%.0f',mod(x,10));
        x=x+1;
    end
    x=x-2;
    for l=1:i-1
        fprintf('%.0f',mod(x,10));
        x=x-1;
    end
    fprintf('\n');
end