EJERCICIOS

DE
MATLAB
*RESOLVER ECUACION DE SEGUNDO GRADO

Escribe un programa en Matlab que pida al usuario a, b, c de la ecuación ax^2+bx+c=0 y calcula sus soluciones. Trabaja sólo con números reales.

Resolver ecuación de segundo grado ax^2+bx+c=0

a = input('Introducir "a": ');
b = input('Introducir "b": ');
c = input('Introduce "c": ');
if a == 0
fprintf('Por favor, introduce "a" distinto de 0 para que sea una ecuación de segundo grado\n');
else
if b^2-4*a*c >= 0
x1 = (-b+(b^2-4*a*c)^(1/2))/(2*a);
x2 = (-b-(b^2-4*a*c)^(1/2))/(2*a);
if x1==x2
fprintf('x = %f (doble)\n',x1);
else
fprintf('x1 = %f\n x2 = %f\n',x1,x2);
end
else
fprintf('Uhhh... Tiene soluciones complejas, sry!\n');
end
end

*CONVERSOR DE GRADOS FAHRENHEIT A CELSIUS

Realizar un programa en Matlab que permita pasar de grados Fahrenheit a Celsius.

% Obtener Fahrenheit
f = input('Introduce grados Fahrenheit: ');
% Cálculo Celsius
c = (f-32)*5/9;
% Imprimir resultado
fprintf('%f grados Fahrenheit equivalen a %f grados Celsius\n',f,c);
*REPRESENTAR EN UNA GRÁFICA UN VECTOR FRENTE A OTRO DE DIMENSIÓN 100

Crear un vector x de dimensión 100, cuyas componentes son los valores: x_k = -1.001+0.01*k

Calcular a continuación un vector y cuyas componentes vienen dadas por y_k = \frac{sen(x_k)}{x_k}. Finalmente se ha de representar gráficamente y
frente a x.

Generar vector de 1 a 100

aux = 1:100;
% Calcular x y
x = -1.001 + 0.01 .* aux;
y = ((sin(x))./x);
% Representar y frente a x
plot(x,y);

*REPRESENTAR FUNCIÓN ENTRE UNOS VALORES DE ABCISAS DADOS

Leer del teclado un par de abcisas x_1, x_2. Representar gráficamente la función y = x - sen(x) utilizando cien puntos equiespaciados entre x_1, x_2.

Leer x1 y x2
x1 = input('Introduce x1: ');
x2 = input('Introduce x2: ');
% Calcular saltos entre x1 y x2, mediante la fórmula (x2-x1)/(N-1)
k = (x2 - x1)/(100-1);
% Calcular variables
x = x1:k:x2;
y = x - sin(x);
% Representar
plot(x,y);
*PROGRAMAR MENÚ MATEMÁTICO

Programar un menú matemático simple. El programa ha de leer un número x y luego aceptar una opción elegida por el usuario. Si la opción es 1 se ha
de escribir el valor absoluto de x, si es 2 se ha de escribir x^2, si es 3 aparecerá x^3, finalmente si es 4 se escribirá x!.

% Obtener x
x = input('Escribe x: ');
% Crear menú
operacion = input('Escribe\n"1" para realizar el valor absoluto\n"2" para elevarlo al cuadrado\n"3" para
elevarlo al cubo\n"4" para hacer el factorial:\n');
% Calcular
if operacion == 1
x = abs(x);
fprintf('El valor absoluto es %f\n',x);
elseif operacion == 2
x = x^2;
fprintf('El cuadrado es %f\n',x);
elseif operacion == 3
x = x^3;
fprintf('El cubo es %f\n',x);
elseif operacion == 4
x = factorial(x); % Podríamos hacer un bucle pero es mejor utilizar la función factorial de matlab
fprintf('El factorial es %f\n',x);
end
fprintf('Se te fue la mano\n');
end

*ESCRIBIR UNA LISTA DE NÚMEROS PRIMOS

Crea un programa en Matlab que genere una lista con un determinado número de números primos (dado por el usuario, por ejemplo).

% Introducir el número de elementos que quermos

n = input('¿Cuántos números primos quieres que te muestre en pantalla? ');
% Comprobamos desde 1 hasta conseguir n números primos
count = 1;
i = 2;
while count < = n
d = 2;
while mod(i,d) ~= 0
d = d+1;
end
if i == d
fprintf('%d ',i);
count = count+1;
end
i = i+1;
end
fprintf('\n');

El ejemplo anterior será siempre válido mientras no se excedan los 25000 caracteres por línea (llegaría hasta el número 42181), de modo que si
queremos un número más elevado tendremos que dar saltos de línea cada x números representados. Así por ejemplo, con 20 números por línea
sería:

% Introducir el número de elementos que queremos

n = input('¿Cuántos números primos quieres que te muestre en pantalla? ');
% Comprobamos desde 1 hasta conseguir n números primos
count = 1;
semicounter = 1;
i = 2;
while count < = n
d = 2;
while mod(i,d) ~= 0
d = d+1;
end
if i == d
fprintf('%d ',i);
count = count+1;
semicounter = semicounter+1;
if semicounter > 20
fprintf('\n');
semicounter = 1;
end
 end
i = i+1;
end
fprintf('\n');

Otra forma mucho más eficiente sería utilizar la función isprime de matlab. De este modo optimizaríamos mucho los cálculos .

% Introducir el número de elementos que quermos

n = input('¿Cuántos números primos quieres que te muestre en pantalla? ');
% Comprobamos desde 1 hasta conseguir n números primos
count = 1;
semicounter = 1;
i = 2;
while count < = n
if isprime(i)
fprintf('%d ',i);
count = count+1;
semicounter = semicounter+1;
if semicounter > 20
fprintf('\n');
semicounter = 1;
end
end
i = i+1;
end

También es posible reducir significativamente el tiempo de ejecución si tenemos en cuenta sólo los números impares (excepto el 2).

% Introducir el número de elementos que quermos

n = input('¿Cuántos números primos quieres que te muestre en pantalla? ');
% Comprobamos desde 1 hasta conseguir n números primos
count = 1;
semicounter = 1;
i = 2;
while count <= n
 if isprime(i)
fprintf('%d (%d) ',i,count);
count = count+1;
semicounter = semicounter+1;
if semicounter > 20
fprintf('\n');
semicounter = 1;
end
end
if i == 2
i = i+1;
else
i = i+2;
end
end
fprintf('\n');

*SUCESION EN MATLAB

Escriba los n primeros términos de la sucesión dada por a_n = (1+\frac{1}{n})^n , siendo n un numero entero positivo dado.

% Pedimos 'n'
n = input('Introduce n: ');
% Creamos un bucle, en este caso, for es el más efectivo
for i=(1:n)
a=(1+1/i)^i; % Realizamos la operación
fprintf('a%d = %g\n',i,a); % Imprimimos el resultado
end

*SUCESIÓN DE FIBONACCI

Crea un programa en matlab que genere un número determinado de términos de la serie de Fibonacci. Usa variables persistentes y funciones.

function Fibonacci
n = input('¿Cuántos términos de la serie quieres que te muestre? ');
 for i=1:n % Iniciamos un bucle
if i==1 || i==2 % Creamos una condición especial para los términos 1 y 2
number = 1;
else
number = get_term; % Llamamos la función
end
fprintf('%d ',number);
end
fprintf('\n');
clear all;
end
function nu = get_term % Definimos la función
persistent primero;
persistent segundo;
if isempty(primero)
primero = 1;
end
if isempty(segundo)
segundo = 1;
end
nu = primero + segundo;
primero = segundo;
segundo = nu;
end

*SUSTITUIR CARACTERES EN UNA CADENA DE TEXTO EN MATLAB

Genera un programa para sustituir los espacios de una cadena de texto introducida por el usuario por guiones.

function sustituir_espacios
texto = input('Introduce el texto que quieras: ','s');
result = eliminar_espacios(texto);
fprintf('%s\n',result);
end
function r = eliminar_espacios(txt)
n = length(txt);
for i=1:n
 if txt(i) == ' '
txt(i) = '-';
end
end
r = txt;
end

*LEER COMPONENTES DE UN VECTOR Y ESCRIBIRLO

Programar en Matlab: Leer las 5 componentes de un vector v y escribirlo al derecho y al revés.

% Leer componentes
a = input('Primera componente: ');
b = input('Segunda componente: ');
c = input('Tercera componente: ');
d = input('Cuarta componente: ');
e = input('Quinta componente: ');
% Generar e imprimir vector v
v = [a b c d e]
% Generar e impimir vector v2
v2 = [e d c b a]

Una alternativa sería:

% Introducir vector
v = input('Escribe el vector: ');
longitud=length(v);
disp(v);
for i=1:longitud
j(longitud-i+1) = v(i);
end
disp(j);
*FUNCIÓN PARA CALCULAR LA RAÍZ CUADRADA DE NÚMEROS ENTEROS

Codifica y prueba el algoritmo que calcula la raíz cuadrada aproximada entera por defecto (sin emplear funciones de Matlab)

num = input('Raíz de... ');

i=1;
while i*i < num
i=i+1;
end
disp(i);

*SUMATORIO DEL INVERSO DE UNA POTENCIA

Se desea calcular la suma   siendo m y n dos números enteros que se suponen dados.

% Sumatorio de inversas de potencias

function sumatorio2
n=2; % Un número dado cualquiera
m=3; % Otro número dado
s=0;
for k=1:n
s=s+(1/(k^m));
end
disp(s);
end

*SUMATORIO DE LOS INVERSOS DE LA SUCESIÓN DE FIBONACCI

Se desea calcular la suma   siendo los valores   los elementos de la sucesión dada por   con   y  . El
límite n ha de leerse del teclado y se supone mayor que dos.
% Sumatorio de Fibonacci^-1
function sumatorio
n=input('Introduce n: ');
s=0;
a(1)=1;
a(2)=1;
for i=3:n
a(i)=a(i-1)+a(i-2);
end
for k=1:n
s=s+1/a(k);
end
disp(s);
end

*CALCULAR ÁREA DE UNA CORONA CIRCULAR

Dados dos radios, calcular el área de la corona circular.

function AreaCoronaCircular
r = leeRadio;
d = surf(r);
disp(d);
end
function r = leeRadio
r(1,1)=input('Introduce radio mayor: ');
r(1,2)=input('Introduce radio menor: ');
end
function y = surf(r)
y = pi*(r(1,1)^2-r(1,2)^2);
end

*GENERAR FILAS DE ASTERISCOS EN MATLAB

Genera filas de asteriscos en Matlab, de modo que de un resultado similar a este:

*****

****

***

**

function asteriscos
n=input('Filas de *: ');
for i=1:n
for j=n-i:-1:0
fprintf('*');
end
fprintf('\n');
end
end

*GENERAR FILAS DE ASTERISCOS EN MATLAB (EN PIRÁMIDE)

Genera en Matlab una pirámide de asteriscos de n filas (invertida)

function asteriscos_mod
n=input('Nº de filas: ');
for i=1:n
esp=i-1;
for e=1:esp
fprintf(' ');
end
for j=1:0.5:n+1-i
fprintf('*');
end
fprintf('\n');
end
end

*BUSCAR POSICIÓN DE UNA LETRA EN UNA CADENA

Busca la primera posición de una letra en una cadena de texto en Matlab.

function busca_letras
texto=input('Introduce texto: ','s');
simbolos=input('Buscar letras: ','s');
lt=length(texto);
ls=length(simbolos);
for i=1:ls
for j=1:lt
if texto(j) == simbolos(i)
fprintf('SÍMBOLO %s en posición %d\n',simbolos(i),j);
break;
end
if j == lt
fprintf('SÍMBOLO %s no aparece\n',simbolos(i));
end
end
end
end

*DETECTAR TIPO DE TRIÁNGULO DADOS SUS LADOS

Dados los lados de un triángulo determinar si es un triángulo equilátero, isósceles o escaleno, si es que existe.

function check_triangulo
l1 = input('Lado 1: ');
l2 = input('Lado 2: ');
l3 = input('Lado 3: ');
if l1 < l2+l3 && l2 < l1+l3 && l3 < l1+l2
if l1 == l2 && l2 == l3
fprintf('Equilátero\n');
elseif l1 == l2 || l2 == l3 || l1 == l3
fprintf('Isósceles\n');
else
fprintf('Escaleno\n');
end
else
fprintf('No es un triángulo\n');
end
end

*CALCULAR COEFICIENTE BINOMIAL

Crea un programa en Matlab que calcule el coeficiente binomial  , siendo n,m>0 números pedidos al usuario.

function combinatoria
n=input('n: ');
m=input('m: ');
if n > m
comb = fact(n)/(fact(m)*fact(n-m));
disp(comb);
end
end
function facto = fact(n)
if n == 1
facto = 1;
else
facto = n*fact(n-1);
end
end
*NÚMEROS PRIMOS GEMELOS MATLAB

Dos números son primos gemelos si están separados a una distancia de 2. Ejemplos: 5-7; 3-5
Determina una lista con los primeras n parejas de números primos gemelos

function lista_gemelos
n=input('¿Hasta qué número compruebo? ');
lista = [];
for i=1:n-2
if pgemelos(i,i+2)
lista = [lista;i i+2];
end
end
disp(lista);
end
function v = pgemelos(p1,p2)
v=0;
if es_primo(p1) == 1 && es_primo(p2) == 1
if p2-p1 == 2
v=1;
end
end
end
function v = es_primo(n)
v=1;
for i=2:n-1
if mod(n,i) == 0
v=0;
return;
end
end
end
*CALCULAR LETRA DEL DNI EN MATLAB

Crea un programa que devuelva la letra de un DNI aportando sólo la parte numérica. La letra del DNI (España) no es arbitraria, sino que se obtiene de
la siguiente manera: El resto de dividir el número completo entre 23 se le asigna un valor recogido en esta tabla:

Resto 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
Valor T R W A G M Y F P D X B N J Z S Q V H L C K E

function letra_dni
dni = input('Introduce tu DNI (sólo los números): ');
resto = mod(dni,23);
if resto == 0
letra = 'T';
elseif resto == 1
letra = 'R';
elseif resto == 2
letra = 'W';
elseif resto == 3
letra = 'A';
elseif resto == 4
letra = 'G';
elseif resto == 5
letra = 'M';
elseif resto == 6
letra = 'Y';
elseif resto == 7
letra = 'F';
elseif resto == 8
letra = 'P';
elseif resto == 9
letra = 'D';
elseif resto == 10
letra = 'X';
elseif resto == 11
 letra = 'B';
elseif resto == 12
letra = 'N';
elseif resto == 13
letra = 'J';
elseif resto == 14
letra = 'Z';
elseif resto == 15
letra = 'S';
elseif resto == 16
letra = 'Q';
elseif resto == 17
letra = 'V';
elseif resto == 18
letra = 'H';
elseif resto == 19
letra = 'L';
elseif resto == 20
letra = 'C';
elseif resto == 21
letra = 'K';
else
letra = 'E';
end
fprintf('Tu letra es: %s\n',letra);
end

*SOLUCIÓN DE SISTEMAS DE ECUACIONES LINEALES

Un sistema de ecuaciones lineales puede representarse mediante una expresión matricial:

Si A es la matriz de coeficientes y B la matriz de términos independientes, entonces :  . Crea un programa que pida la
matriz A y B y calcule el resultado del sistema.

function resolver_sistema
matA = input('Introduce la matriz de coefiecientes A: ');
matB = input('Introduce la matriz de términos independientes B: ');
% Comprobaciones
[ma,na] = size(matA);
[mb,nb] = size(matB);
if ma ~= mb || nb ~= 1
fprintf('Existen problemas con las dimensiones de tus matrices\n');
else
if ma ~= na
fprintf('La matriz A tiene que ser cuadrada\n');
else
matX = matA^(-1)*matB;
disp(matX);
end
end
end

* COMPROBAR SI UN NÚMERO ES ABUNDANTE

Escribe un programa en Matlab que devuelva si un número es abundante o no. Nota: Un número es abundante si la suma de sus divisores es mayor
que el doble de dicho número. Ej: 12, 18, 20, 24…

function abundante
n=input('¿Es abundante? ');
if n == 1
fprintf('%d no es abundante\n',n);
else
v=divisores(n);
s=suma(v);
if s > n
fprintf('%d es abundante\n',n);
 else
fprintf('%d no es abundante\n',n);
end
end
end
function v = divisores(n)
j=1;
for i=1:n-1
if mod(n,i) == 0
v(j) = i;
j = j + 1;
end
end
end
function s = suma(v)
n=length(v);
s = 0;
for i=1:n
s = s + v(i);
end
end

*COMPROBAR SI DOS PALABRAS SON ANAGRAMAS

Un anagrama es una palabra generada a través de la ordenación de las letras de otra palabra. Escribe un programa en Matlab que pueda decir si dos
palabras son o no anagramas. Ej: onidi – indio

function anagrama
cad1=input('Introduce una palabra: ','s');
cad2=input('Introduce otra palabra: ','s');
if length(cad1) == length(cad2)
cad1=ordena(cad1);
cad2=ordena(cad2);
for i=1:length(cad1)
if cad1(i) ~= cad2(i)
fprintf('No son anagramas\n');
return;
 end
end
fprintf('Son anagramas\n');
else
fprintf('No son anagramas\n');
end
end
function r = ordena(cad)
l=length(cad);
j=0;
while j<l
for i=1:l-1
j = j+1;
if cad(i) < cad(i+1)
aux = cad(i);
cad(i) = cad(i+1);
cad(i+1) = aux;
j = 0;
end
end
end
r=cad;
end

* CALCULAR RECTÁNGULO DE ÁREA MÁXIMA SUJETO A UN PERÍMETRO

Calcula los lados de un rectángulo que maximice su área pidiendo al usuario el perímetro máximo de dicho rectángulo.

% Maximiza áera sujeto a perímetro

perimetro=input('¿Perímetro máximo? ');
area_max = 0;
for L1=1:0.1:perimetro/2 %0.1 representa el nivel de precisión
L2=perimetro/2-L1;
area=L1*L2;
if area > area_max
area_max = area;
L1_max = L1;
 L2_max = L2;
end
end
fprintf('Los lados son L1 = %.2f, L2 = %.2f (Área = %.2f)\n',L1_max,L2_max,area_max);

*BUSCAR LA POSICIÓN DE UNA PALABRA EN UNA CADENA DE TEXTO

Crea un programa en Matlab capaz de buscar todas las posiciones de una palabra en una cadena de texto. Pide tanto el texto como la palabra.

function buscar_palabra
texto=input('Texto: ','s');
busca=input('Buscar: ','s');
lt=length(texto);
lb=length(busca);
for i = 1:lt-lb+1
for j = 1:lb
if texto(i-1+j) ~= busca(j)
break;
end
if j == lb
disp(i);
end
end
end
end

*CODIFICAR / DECODIFICAR UNA MATRIZ EN UN VECTOR

Dada una matriz, crear un programa que la codifique en un vector de la forma: v = [coordenada_X1 coordenada_Y1 valor_X1Y1 coordenada_X1
coordenada_Y2 valor_X1Y2 …]

Solución para codificar:

% Codificar matriz
function codificar_matriz
A=input('Introduce una matriz para codificar: ');
[v,prop] = codifica(A);
fprintf('Matriz codificada:\n');
disp(v);
fprintf('Proporción ~= 0: %.2f\n',prop);
end
function [v,prop] = codifica(A)
[r,c] = size(A);
num=r*c;
pos=1;
for m=1:r
for n=1:c
if A(m,n) ~= 0
v(pos) = m;
v(pos+1) = n;
v(pos+2) = A(m,n);
pos = pos + 3;
end
end
end
[~,comp] = size(v);
prop = 100*comp/(3*num);
end

 Solución para decodificación:

function decodifica_matriz
v=input('Decodifica matriz: ');
A=decodifica(v);
disp(A);
end
function A = decodifica(v)
l = length(v);
for i=1:3:l-2
A(v(i),v(i+1)) = v(i+2);
end
end

*COMPARAR CADENAS DE TEXTO UTILIZANDO UN COMODÍN *

Compara dos cadenas de texto pedidas al usuario. La primera es el texto a comparar y la otra es la plantilla. En caso de que la cadena contenga
números, la plantilla puede tener ‘*’ en vez de los números correspondientes. La función devolverá ‘1’ si la comparación es exitosa y ‘0’ en cualquier
otro caso. Ejemplos:

 hola <-> hola –> 1

 holaaa <-> hola –> 0
 hola <-> heyy –> 0
 hola73 <-> hola73 –> 0
 hola73 <-> hola** –> 1
 h1l4 <-> h*l4 –> 1

% Comparar texto con plantilla

cad=input('Introduzca texto: ','s');
plantilla=input('Introduzca plantilla: ','s');
Lc=length(cad);
Lp=length(plantilla);
if Lc == Lp
for i=1:Lc
if (cad(1,i) == plantilla(1,i)) || ((cad(1,i) == '0' || cad(1,i) == '1' || cad(1,i) == '2' || cad(1,i)
== '3' || cad(1,i) == '4' || cad(1,i) == '5' || cad(1,i) == '6' || cad(1,i) == '7' || cad(1,i) == '8' ||
cad(1,i) == '9') && plantilla(1,i) == '*')
r=1;
else
r=0;
break;
end
end
else
r=0;
end
disp(r);
*CONJETURA DE GOLDBACH

Todo número par mayor que 2 puede descomponerse como suma de dos números primos. Programa un algoritmo que dado un número par mayor a
2 devuelva cuáles son esos dos números primos (el mayor y el menor posible).

function goldbach
n=input('Número a descomponer: ');
for i=2:n/2
j=n-i;
if es_primo(i) == 1 && es_primo(j) == 1
fprintf('%d = %d + %d\n',n,i,j);
break;
end
end
end
function v = es_primo(n)
v=1;
for i=2:n-1
if mod(n,i) == 0
v=0;
return;
end
end
end

* CONTADOR DE PALABRAS

Crea un programa en Matlab, que dada una cadena de texto, devuelva el número de palabras que contiene dicha cadena. Supón que las palabras se
separan con espacios y que la última palabra no termina en espacio.

function num_palabras
texto=input('Introduce un texto: ','s');
n=n_words(texto);
fprintf('%d palabra(s)\n',n);
end
function n = n_words(texto)
l=length(texto);
n=1;
for i=1:l
if texto(i) == ' '
n = n+1;
end
end
end

*LOCALIZAR LOS PUNTOS DE SILLA DE UNA MATRIZ

Localiza los puntos de silla de una matriz aleatoria. Considera, en este caso, que un punto de silla es todo elemento dentro de la matriz, que cumple
que es el valor mínimo dentro de su fila y el valor máximo dentro de su columna.

function ptos_silla % Suponiendo no multiplicidades

mat=randi(10,5,5) % No pongo el punto y coma para que muestre en pantalla la matriz generada
minimos=[];
maximos=[];
fprintf('Puntos de silla: ');
for i = 1:5
n=1;
for j = 1:5
if mat(i,n) > mat(i,j)
n = j;
end
end
minimos=[minimos;i n];
end
for i = 1:5
n=1;
for j = 1:5
if mat(n,i) < mat(j,i)
n = j;
end
end
 maximos=[maximos;n i];
end
for i = 1:5
for j = 1:5
if minimos(i,1) == maximos(j,1) && minimos(i,2) == maximos(j,2)
fprintf('(%d,%d) ',minimos(i,1),minimos(i,2))
end
end
end
fprintf('\n');
end

*REPRESENTAR GRÁFICA DE UNA FUNCIÓN CON ESTILO

Representa gráficamente el coseno de un ángulo α de 0 a 2π con un salto de π/8. Titula adecuadamente cada uno de los ejes así como la gráfica
resultante. A continuación añade a esa gráfica la del seno de α. Coloca leyendas para distinguir ambas gráficas. Añade un mallado. Edita las
propiedades de las líneas para cambiar los colores, grosores y estilos de punto de las gráficas que has generado.

function grafica_cos_up
x=0:pi/8000:2*pi;
y=cos(x);
y_2=sin(x);
plot(x,y,'-.r',x,y_2,'k');
grid on;
title('Representación de seno y coseno');
xlabel('Radianes');
ylabel('Valor');
legend('cosx','sinx')
end

*NÚMERO DE MONEDAS

Disponiendo de las monedas fraccionarias del euro (50, 20, 10, 5, 2 y 1 cent), calcular el mínimo número de monedas que se han de entregar para
pagar cualquier importe en céntimos. El programa solicita el importe y presenta la cantidad a entregar de cada tipo de moneda.
function n_monedas
precio = input('Precio: ');
monedas = [50 20 10 5 2 1; 0 0 0 0 0 0];
total = 0;
while total ~= precio
for i = 1:6
nuevo = total + monedas(1,i);
if precio >= nuevo
total = total + monedas(1,i);
monedas(2,i) = monedas(2,i) + 1;
break;
end
end
end
for j = 1:6
if monedas(2,j) ~= 0
fprintf('%d moneda(s) de %d céntimo(s)\n',monedas(2,j),monedas(1,j));
end
end
end

*DIBUJAR POLÍGONOS DE N LADOS

Realizar un programa que dibuje en la pantalla un polígono regular de n lados, siendo n > 2, un número leído previamente. Utilice funciones
trigonométricas para calcular la posición de los vértices en el plano y las funciones de dibujo para trazar el polígono. Suponga que el centro del
polígono está en el origen y que el primer vértice está sobre el eje OX. La longitud del lado será 1 en todo caso.

% Polígono regular de n lados

function dibujar_poligono
n = input('¿Cuántos lados tiene el polígono? ');
angulo = (n-2)*pi/n;
alfa = 2*pi/n;
beta = (2*pi-angulo)/2;
coseno = cos(alfa);
x = zeros(1,n);
y = zeros(1,n);
x(1) = (coseno+sqrt(coseno^2+2))/2;
y(1) = 0;
for i=2:n
x(i) = cos(beta) + x(i-1);
y(i) = sin(beta) + y(i-1);
beta = beta + pi - angulo;
end
for i=1:n
if i==n
line([x(i),x(1)],[y(i),y(1)]);
else
line([x(i),x(i+1)],[y(i),y(i+1)]);
end
end
end

*DIBUJAR CIRCUNFERENCIA COMO UN POLÍGONO DE N LADOS

Realice un programa que permita dibujar una circunferencia aproximada como un polígono regular de 200 lados.

% Circunferencia como polígono de 200 lados

function dibujar_circunferencia
n=200; % Número de lados
r=1; % Radio
alfa=2*pi/n;
termino=alfa;
for i=1:n
x(i)=r*cos(alfa);
y(i)=r*sin(alfa);
alfa=alfa+termino;
end
for i=1:n
if i==n
line([x(i),x(1)],[y(i),y(1)]);
else
line([x(i),x(i+1)],[y(i),y(i+1)]);
end
end
end

*DIBUJAR ELIPSE COMO POLÍGONO DE N LADOS

Generalice el problema de representar una circunferencia para una elipse formada por un polígono de 200 lados. Se tomará el semieje horizontal
igual a 1 y el vertical igual a v, siendo v un número que habrá de leerse del teclado.

% Elipse como polígono de 200 lados

function dibujar_elipse
n=200; % Número de lados
u=1; % Semieje en OX
v=input('Introduce el valor del semieje en OY: '); % Semieje en OY
alfa=2*pi/n;
termino=alfa;
for i=1:n
x(i)=u*cos(alfa);
y(i)=v*sin(alfa);
alfa=alfa+termino;
end
for i=1:n
if i==n
line([x(i),x(1)],[y(i),y(1)]);
else
line([x(i),x(i+1)],[y(i),y(i+1)]);
end
end
end
*CONVERSOR DE DECIMAL A BINARIO

Crea un programa que convierta un número decimal a binario.

function conv_binario
n=input('Número decimal: ');
num=[];
binario=con_bin(num,n);
disp(binario);
end
function v = con_bin(num,n)
if n == 1
v=1;
else
num=[con_bin(num,fix(n/2)) mod(n,2) num];
v=num;
end
end

*CONVERSOR A NÚMEROS ROMANOS

Dado un número decimal, crear un programa que lo convierta al sistema de números romanos. Considera números del 1 al 999.

% Codificar a números romanos

function num_romanos
ok = 0;
while ok == 0
num=input('Escribe un número (máx. 3 cifras): ');
if num < 1000 && num > 0
ok = 1;
end
end
v=separar(num);
for i=3:-1:1
if v(i) ~= 0
texto=conversor(v(i),i);
fprintf('%s',texto);
end
end
fprintf('\n');
end
function v = separar(num)
if num < 10
l = 1;
elseif num < 100
l = 2;
else
l = 3;
end
v=zeros(1,3);
for i=1:l
v(i) = mod(num,10);
num=fix(num/10);
end
end
function texto = conversor(num,orden)
texto = '';
if orden == 1
if num == 1
texto = 'I';
end
if num == 2
texto = 'II';
end
if num == 3
texto = 'III';
end
if num == 4
texto = 'IV';
end
if num == 5
 texto = 'V';
end
if num == 6
texto = 'VI';
end
if num == 7
texto = 'VII';
end
if num == 8
texto = 'VIII';
end
if num == 9
texto = 'IX';
end
end
if orden == 2
if num == 1
texto = 'X';
end
if num == 2
texto = 'XX';
end
if num == 3
texto = 'XXX';
end
if num == 4
texto = 'XL';
end
if num == 5
texto = 'L';
end
if num == 6
texto = 'LX';
end
if num == 7
texto = 'LXX';
end
if num == 8
texto = 'LXXX';
 end
if num == 9
texto = 'XC';
end
end
if orden == 3
if num == 1
texto = 'C';
end
if num == 2
texto = 'CC';
end
if num == 3
texto = 'CCC';
end
if num == 4
texto = 'CD';
end
if num == 5
texto = 'D';
end
if num == 6
texto = 'DC';
end
if num == 7
texto = 'DCC';
end
if num == 8
texto = 'DCCC';
end
if num == 9
texto = 'CM';
end
end
end
*EL JUEGO DE LA VIDA EN MATLAB

Se desea simular en una computadora el juego de la vida, que consiste en simular la evolución de una colonia de células distribuidas aleatoriamente
en una cuadrícula siguiendo ciertas reglas. Para ello, dada la disposición de la cuadrícula en un tiempo T se calcula la evolución en un tiempo posterior
T+1 siguiendo las reglas siguientes:

 Una célula sola (sin vecinas) en T muere por aislamiento en T+1

 Cada célula con dos células vecinas en T sobrevive en T+1
 En una casilla vacía con exactamente 3 células vecinas en T, nace una nueva célula en T+1
 En una casilla con una célula que tiene 3 o más células vecinas en T, muere por asfixia en T+1

Utiliza Matlab para generar la simulación mediante matrices de tamaño arbitrario.

function game_life
n=10; % tamaño del mundo
t=10; % vida del mundo
world=condiciones_ini(n);
fprintf('Origen del mundo:\n');
disp(world);
for i=1:t
world=actualizar_mundo(world);
fprintf('Mundo en t=%d\n',i);
disp(world);
end
end
function enviroment=condiciones_ini(n)
enviroment=randi(2,n)-1;
end
function world = actualizar_mundo(world)
[m,n] = size(world);
for i=1:m
for j=1:n
 if n_adyacentes(world,i,j) == 0
world(i,j)=0;
end
if n_adyacentes(world,i,j) == 3
world(i,j)=1;
end
if n_adyacentes(world,i,j) > 3
world(i,j)=0;
end
end
end
end
function cont = n_adyacentes(world,i,j)
[m,n] = size(world);
cont=0;
if i>1 && j>1 && world(i-1,j-1) == 1
cont = cont+1;
end
if i>1 && world(i-1,j) == 1
cont = cont+1;
end
if i>1 && j<n && world(i-1,j+1) == 1
cont = cont+1;
end
if j>1 && world(i,j-1) == 1
cont = cont+1;
end
if j<n && world(i,j+1) == 1
cont = cont+1;
end
if i<m && j>1 && world(i+1,j-1) == 1
cont = cont+1;
end
if i<m && world(i+1,j) == 1
cont = cont+1;
end
if i<m && j<n && world(i+1,j+1) == 1
cont = cont+1;
end
end

Otra posible solución, algo más gráfica, que se ejecuta paso a paso (usa variables persistentes).

function game_life_v2
n=10; % tamaño del mundo
persistent world
persistent cont
if isempty(cont)
cont=0;
else
cont=cont+1;
end
if isempty(world)
world=condiciones_ini(n);
fprintf('Origen del mundo:\n');
contourf(world);
colormap(hot(8));
else
world=actualizar_mundo(world);
fprintf('Mundo en t=%d\n',cont);
contourf(world);
colormap(hot(8));
end
end
function enviroment=condiciones_ini(n)
enviroment=randi(2,n)-1;
end
function world = actualizar_mundo(world)
[m,n] = size(world);
for i=1:m
for j=1:n
if n_adyacentes(world,i,j) == 0
world(i,j)=0;
end
 if n_adyacentes(world,i,j) == 3
world(i,j)=1;
end
if n_adyacentes(world,i,j) > 3
world(i,j)=0;
end
end
end
end
function cont = n_adyacentes(world,i,j)
[m,n] = size(world);
cont=0;
if i>1 && j>1 && world(i-1,j-1) == 1
cont = cont+1;
end
if i>1 && world(i-1,j) == 1
cont = cont+1;
end
if i>1 && j<n && world(i-1,j+1) == 1
cont = cont+1;
end
if j>1 && world(i,j-1) == 1
cont = cont+1;
end
if j<n && world(i,j+1) == 1
cont = cont+1;
end
if i<m && j>1 && world(i+1,j-1) == 1
cont = cont+1;
end
if i<m && world(i+1,j) == 1
cont = cont+1;
end
if i<m && j<n && world(i+1,j+1) == 1
cont = cont+1;
end
end