INFORMÁTICA (MATLAB)

Programas resueltos
- Hechos en clase
- Ejercicios resueltos
- Programas de examen

Victoria Prieto (Vicky)

En este “libro” encontraréis una colección de aproximadamente 80
programas resueltos en MATLAB.
Entre ellos se encuentran todos los programas resueltos en clase por
el profesor en el curso 2015/16, además de los ejercicios de boletín
propuestos y otros ejercicios adicionales de examen, organizados por
orden alfabético (tal y como los encontré en mi carpeta).
Todos estos programas son los que hice de cara al examen, espero que
os sirvan para aprobar.
-Vicky-
ALGORITMO DE INSERCIÓN

% Algoritmo de inserción
function algoritmo_insercion
v=[2 5 6 9 11 13];
x=input('x= ');
v=inserta(v,x);
disp(v);
end

function v=inserta(v,x)
L=length(v);
i=1;
% Búsqueda del punto de inserción
while i<=L && x>v(i) % Mientras no me salga del vector y comparamos con
el valor de x cada valor del vector
i=i+1;
end
% Desplazamos componentes remanentes una posición hacia abajo. Empezamos
% por el últmo valor
j=L;
while j>=i
v(j+1)=v(j);
j=j-1;
end
v(i)=x;
end

ALGORITMO DE BÚSQUEDA

%Algoritmo de búsqueda
function algoritmos_busqueda
v=[5 7 9 -2 8 6];
x=input('x= ');
r=busqueda_lineal_todos(v,x);
%r=posicion del elemento buscado en el vector v. =0 si no lo encuentra
disp(r);
end

function r=busqueda_lineal(v,x)
L=length(v);
r=0;
for i=1:L
if v(i)==x
r=i;
end
end
end
%Esta función busca un determinado valor dentro de un vector; si lo
%encuentra, r tomará el valor de la posición en la que se halla dicho
valor
%dentro del vector. En caso contrario, r seguirá siendo 0.
function r=busqueda_lineal_todos(v,x)
%Devuelve en r un ector con todas las posiciones donde haya coincidencia.
%r=1 si no hay ninguna
L=length(v);
r=[];%vector vacío inicialmente
cont=1;
for i=1:L
if v(i)==x
%r=[r i]; %añadimos una componente más al vector (esta sería una
%forma de hacerlo)
r(cont)=i;
cont=cont+1; %Segunda forma de hacerlo
end
end
end

ANAGRAMA

%Ejercicio 3.5: Identificación de anagramas

function anagrama(cad1,cad2)
r=identificaSimbolo(cad1,cad2);
if r==1
disp('Es un anagrama');
else
disp('No es un anagrama');
end
end

function [r]=identificaSimbolo(cad1,cad2)
N=length(cad1);
M=length(cad2);
i=1;
j=1;
r=0; %Suponemos inicialmente que no hay coincidencia alguna
for i=1:N
for j=1:M
if cad1(i)==cad2(j)
r=1;
end
end
end
end

ÁREA DEL CÍRCULO

%Cálculo del área círculo

function area_circulo
r=input('Radio del círculo: ');
a=area(r);
fprintf('El área es %f\n',a);
end

function A=area(radio)
A=3.1415*radio*radio;
end

BUSCA-CADENA

%Ejercicio 3.6: Búsqueda de una cadena dentro de otra

function [pos]=busca_cadena(buscada,texto)
N=length(texto);
M=length(buscada);
r=0;
cont=0;
i=1;
pos=[];
while i<=N && r==0
k=i;
for j=1:M
if buscada(j)==texto(i)
cont=cont+1;
pos=[pos,i];
end
if cont==M
r=1;
else
pos=[];
end
i=k+1;
end
end

BÚSQUEDA

% Búsqueda binaria
function busqueda_algoritmo
v=[5 -2 0 3 7 9 9];
x=input('x= ');
r=busqueda_binaria(v,x);
%r=posicion del elemento buscado en el vector v. =0 si no lo encuentra
disp(r);
end

function r=busqueda_binaria(v,x)
%Suponemos vector v ordenado de menor a mayor
L=length(v);
i=1;
j=L;
while i<=j %mientras i sea menor que j, el vector puede seguir
dividiendose
m=fix((i+j)/2); %fix permite truncar
if v(m)==x
r=m; %La hemos encontrado
i=j+1; %Para forzar salida del bucle
elseif v(m)>x
j=m-1; %Nos quedamos con la mitad izquierda de v
elseif v(m)<x
 i=m+1; %Nos quedamos con la mitad derecha de v
end
end
end

%si hubiera varios elementos iguales dentro del vector, habría que
refinar
%la búsqueda moviéndose a izquierda y derecha hasta encontrar dichos
%elementos

BÚSQUEDA BINARIA

% Búsqueda binaria
function algoritmos_busqueda
v=[5 7 9 -2 8 6];
x=input('x= ');
r=busqueda_binaria(v,x);
%r=posicion del elemento buscado en el vector v. =0 si no lo encuentra
disp(r);
end

function busqueda_binaria(v,x)
%Suponemos vector v ordenado de menor a mayor
L=length(v);
i=1;
j=L;
while i<=j %mientras i sea menor que j, el vector puede seguir
dividiendose
m=fix((i+j)/2); %fix permite truncar
if v(m)==x
r=m; %La hemos encontrado
i=j+1; %Para forzar salida del bucle
elseif v(m)>x
j=m-1; %Nos quedamos con la mitad izquierda de v
elseif v(m)<x
i=m+1; %Nos quedamos con la mitad derecha de v
end
end
end

BÚSQUEDA N-NÚMERO ENTERO

% Ejericio 1.9: contar cuantas veces aparece n entre 1 y 100

function aparicion_cifran
n=input('Introduzca cifra buscada: ');
%Hallamos el número de cifras
N=input('Introduzca valor límite: ');
contador=0;
for i=1:N
c=cont_n(i,n);%función que cuenta cuántas veces aparece n en un
vector
contador=contador+c;
end
disp(contador);
end
function c=cont_n(i,n)
v=zeros;
v=transf_vect(i); %Función que nos transforma el número i en un vector
N=length(v);
c=0;
for i=1:N
if n==v(i)
c=c+1;
end
end
end

function v=transf_vect(i)
m=10;
cont=1;
while fix(i/m)~=0
cont=cont+1;
m=m*10;
end
N=cont; %Dimensión del vector que queremos crear
m=(10^(N-1));
v=zeros;
j=0;
while m>=1
j=j+1;
if j<=N
v(j)=fix(i/m);
i=i-v(j)*m;
end
m=m/10;
end
end

CADENA GUIONES

%Función que, recibiendo una cadena de caracteres, recorre la cadena

%sustituyendo por guiones cada espacio en blanco

function rellenar_guiones
s=input('Cadena= ','s'); %se utiliza 's' para que pueda leer los
caracteres
re=rellena(s); %función que devuelve la cadena con guiones
fprintf('Cadena con guiones=%s\n',re); % el "%s" se usa para que devuelva
caracteres
end

function re=rellena(s)
N=length(s);
for i=1:N
if s(i)==32
re(i)=95;
else
re(i)=s(i);
end
end
end
COMPARACIÓN ALGORITMOS

% comparación de tiempo de ejecución de dos algoritmos

N=1000;

% Algoritmo A: mostrar por pantalla número de 1 a N

for i=1:N %creamos el vector en el que cada componente coincide con su
posición
v(i)=i
end
for i=1:N
disp(v(i));
end
t1=toc;
%La complejidad del primero es mayor porque es como mínimo de 2N, pues
%hay realizar dos iteraciones

%Algoritmo B: Mostrar por pantalla número 1 a N

for i=1:N
disp (i);
end
t2=toc;
fprintf('Algoritmo A=%f seg\n', t1)
fprintf('Algoritmo B=%f seg\n', t2)

%La complejidad de este problema es mucho menor, tan solo tiene que
%realizar una iteración

COMPARACIÓN TRES VALORES

% Ejercicio 1.3: Determinar si hay valores iguales

a=input('Introduzca primer valor(a): ');

b=input('Introduzca segundo valor(b): ');
c=input('Introduzca tercer valor(c): ');
cont=0;
if a==b
cont=cont+1;
end
if a==c
cont=cont+1;
end
if b==c
cont=cont+1;
end
if cont>=2
disp('los tres son iguales');
elseif cont==1
disp('hay dos valores iguales');
elseif cont<1
disp('no hay valores iguales');
end
CONTADOR DE EVENTOS (EJEMPLO VBLE. PERSISTENTE)

%Ejemplo de contador de eventos

function contador_eventos
for i=1:5 %llamadas consecutivas
c=contador; %contador no recibe parámetros
fprintf('llamada %d--c=%d\n',i,c);
end
end

function c=contador
persistent r;
if isempty(r); %si r no existe
r=0; %inicializamos r a cero
end
r=r+1;
c=r;
end

CONVERTIR A MAYÚSCULAS

% Pasar una cadena de caracteres a mayúsculas

function convertir_mayusculas
cad=input('Introduce cadena: ','s');
cadmay=mayusc(cad);
fprintf('Cadena en mayúsculas:%s\n',cadmay);
end

function cadmay=mayusc(cad);
N=length(cad);
for i=1:N
if cad(i)>='a'& cad(i)<='z'
cadmay(i)=cad(i)+'A'-'a';
else
cadmay(i)=cad(i);
end
end
end

CONTADOR DE PALABRAS

%Ejercicio 3.1: Cuenta el número de palabras en una frase

function [n]=cuenta_palabras(cad)
cad=input('Introduzca frase: ','s');
L=length(cad);
n=0;
for i=1:L
if cad(i)==' '
n=n+1;
end
end
n=n+1;
end
DETERMINA TIPO DE TRIÁNGULO

%Ejercicio 2.8: Identificación del tipo de triángulo

function determina_triangulo
a=input('a= ');
b=input('b= ');
c=input('c= ');
%Comprobamos que es un triángulo
if (a+b)>c && (a+c)>b && (b+c)>a
%Comprobamos si es equilátero
if a==b && a==c
disp('Es un triángulo equilátero');
elseif a==b || a==c || b==c
disp('Es un triángulo isósceles');
else
disp('Es un triángulo escaleno');
end
else
disp('No es un triángulo');
end
end

DETERMINA SI ES PRIMO

% Determinar si un número es primo

n=input('Introduce n: ');
d=2;
while mod(n,d)~=0
d=d+1;
end
if d==n
disp('Es primo');
else
disp('No es primo');
end

ECUACIÓN DE SEGUNDO GRADO

% Ejercicio 1.4: Ecuación de segundo grado

a=input('Introduzca coeficiente a: ');

b=input('Introduzca coeficiente b: ');
c=input('Introduzca coeficiente c: ');
%calculamos el discriminante
d=b*b-4*a*c;
if d<0
disp('Soluciones complejas');
d=-d;
im=sqrt(d)/(2*a);
re=-b/(2*a);
fprintf('x1=%.2f\n+i*%.2f\n',re,im);
fprintf('x2=%.2f\n-i*%.2f\n',re,im);
else
x1=(-b+sqrt(d))/(2*a);
x2=(-b-sqrt(d))/(2*a);
 if x1==x2
disp('Solución doble');
fprintf('x=%.2f\n',x1);
elseif (x1==0 & x2==-0)|(x1==-0 & x2==0)
disp('Solución doble');
disp('x=0');
else
fprintf('x1=%.2f\n',x1);
fprintf('x2=%.2f\n',x2);
end
end

EJ. EULER I

% Integración numérica. Aproximación de integrales definidas por el

método de Euler

function ej_Euler_I
a=input('a= ');
b=input('b= ');
n=input('n= '); %Pedimos el número de intervalos
A=Euler_I(a,b,n);
disp(A);
end

%-----------------------------
function A=Euler_I(a,b,n)
a=0;
d=(b-a)/n;
A=0;
for k=0:n-1
A=A+d*f(a+d*k);
end
end

%----------------------------------

function y=f(x)
y=x^2;
end

%%%%Hacerlo también mediante el método de los trapecios

%%%%Hacer la combinación con la interpolación

EJ. EULER II (MÉTODO DE LOS TRAPECIOS)

% Integración numérica. Aproximación de integrales definidas por el

método de Euler con trapecios

function ej_Euler_II
a=input('a= ');
b=input('b= ');
n=input('n= '); %Pedimos el número de intervalos
A=Euler_I(a,b,n);
disp(A);
end

%-----------------------------
function A=Euler_I(a,b,n)
a=0;
d=(b-a)/n;
A=0;
for k=0:n-1
A=A+d*(f(a+d*k)+f(a+(k+1)*d))/2;
end
end

%----------------------------------

function y=f(x)
y=x^2;
end

EJ. INTERPOLACIÓN

%Interpolación lineal

function ej_interpolacion
%Datos del problema
x=[0 1 2 3 4];
y=[-1 3 4 2 6];
%Pedimos punto a interpolar
xast=input('xast= ');
[yast,ok]=interpola(x,y,xast); %La variable ok nos dirá si ha sido o no
posible realizar la interpolación; si xast está fuera del intervalo no se
calculará yast
if ok==1 %Si se ha realizado la interpolación con éxito
fprintf('yast=%.2f\n',yast);
plot(x,y,'k',xast,yast,'r.');
else
disp('xast fuera de rango');
end
end

%------------------------------

function [yast,ok]=interpola(x,y,xast)
%Primero comprobamos que xast está dentro del intervalo. Como el rango
nos lo dan ordenado, solo habra que ver que esté entre x1 y x2
N=length(x); %Nro de parejas de valores x,y
if xast<x(1) || xast>x(N) % Si se sale del rango
ok=0;
yast=0;
else %Si xast está dentro del rango, interpolamos
ok=1;
%Buscar el intervalo donde está xast
i=1;
while x(i)<xast
i=i+1;
end
a=(y(i-1)-y(i))/(x(i-1)-x(i));
b=y(i)-x(i)*a;
 yast=a*xast+b;
end
end

EJ. MÍNIMOS CUADRADOS

%Ejemplo mínimos cuadrados

function ej_minimos_cuadrados
%Datos de ejemplo (aproximadamente sobre y=2*x+1)
x=[0 1 2 3 4 5];
y=[0.8 3.2 4.7 6.9 9.3 11.6];
%Calculamos coeficientes de regresión
[a,b]=min_cuad(x,y);
%Representación gráfica
plot(x,y,'k.',[x(1) X(N)],[a*x(1)+b,a*x(N)+b],'b')
end

%-----------------------------

function min_cuad(x,y)
N=length(x);
%Cálculo de sumatorios
sxk=0;
syk=0;
sxkyk=0;
sxk2=0;
for k=1:N
sxk=sxk+x(k);
syk=syk+y(k);
sxkyk=sxkyk+x(k)*y(k);
sxk2=sxk2+x(k)*x(k);
end
%Se calculan los coeficientes usando los sumatorios calculados y
aplicando las fórmulas correspondientes
a=(N*sxkyk-sxk*syk)/(N*sxk2-sxk*sxk);
b=(syk-a*sxk)/N;
end

EJEMPLO EDO

%Ejemplo ingtegración de EDOs:

%Problema: dx(t)/dt=-2*x(t); x(0)=1

function ejemplo_edo
tfinal=input('tfinal '); %Instante de tiempo en el que queremos finalizar
la simulación
h=input('h= ');
[t,x]= Euler_II(tfinal,h);%Deberá devolver dos vectores, el del tiempo y
el de x
plot(t,x); %Gráfica
end

%-----------------------
function [t,x]=Euler_II(tfinal,h)
%Condiciones iniciales
t(1)=0; %Consideramos que el vector de tiempo comienza en 0
x(1)=1; %Condición inical en x(0), en MATLAB no podemos poner x(0) porque
no hay componente 0 de un vector
k=1;
while t(k)<tfinal
x(k+1)=x(k)+h*(-2*x(k));
t(k+1)=t(k)+h;
k=k+1;
end
end

EJEMPLO EDO PROYECTIL

%Ejemplo EDO Euler: proyectil que cae al suelo en vertical

%F=m*a
%-mg=m*(d^2x(t))/dt^2
%d^2x(t)/dt^2=-g
%x(0)=0
%dx(t)/dt)=vo=10 m/s en t=0

%Este problema no se puede plantear como el de la taza de café, ya que es

%de segundo orden, sino que habrá que plantearlo como un sistema de dos
%ecuaciones de primer orden

%----> dv(t)/dt=-g && dx(t)/dt=v(t)

%----> condiciones iniciales: x(0)=0; v(0)=vo;

%Ejemplo integración : proyectil que cae sin rozamiento

function ejemplo_edo_proyectil
tfinal=input('tfinal '); %Instante de tiempo en el que queremos finalizar
la simulación
h=input('h= ');
x=input('T0= ');
[t,T]= Euler_II(tfinal,h,T0);%Deberá devolver dos vectores, el del tiempo
y el de x
plot(t,T); %Gráfica
end

%-----------------------
function [t,x]=Euler_II(tfinal,h)
%Condiciones iniciales
t(1)=0; %Consideramos que el vector de tiempo comienza en 0
x(1)=0; %Condición inical en x(0), en MATLAB no podemos poner x(0) porque
no hay componente 0 de un vector
v(0)=10; %(m/s) Velocidad inicial
k=1;
flag=0;
while t(k)<tfinal
v(k+1)=v(k)+h*(-9.81)
x(k+1)=x(k)+h*(v(k));
t(k+1)=t(k)+h;
% Si queremos guardar tiempo hasta que T<40ºC
if flag == 1 && x(k)<=40
fprintf('T=40º en t=%f\n',t(k));
 flag = 0;
end
k=k+1;
end

EJEMPLO EDO TAZA DE CAFÉ

%Enfriamiento taza de café

%dT(t)/dt=ka(Ta-T(t))
%Condiciones iniciales: T(0)=60ºC Da igual ºC que K, se mide la
diferencia
%Ta=25ºC

function ejemplo_edo_taza_cafe
tfinal=input('tfinal '); %Instante de tiempo en el que queremos finalizar
la simulación
h=input('h= ');
T0=input('T0= ');
[t,T]= Euler_II(tfinal,h,T0);%Deberá devolver dos vectores, el del tiempo
y el de x
plot(t,T); %Gráfica
end

%-----------------------
function [t,x]=Euler_II(tfinal,h)
%Parámetros del problema
Ta=25; %Temperatura ambiente
ka=0.02; %Constante de transferencia de calor
%Condiciones iniciales
t(1)=0; %Consideramos que el vector de tiempo comienza en 0
x(1)=T0; %Condición inical en x(0), en MATLAB no podemos poner x(0)
porque no hay componente 0 de un vector
k=1;
flag=0;
while t(k)<tfinal
x(k+1)=x(k)+h*(ka*(Ta-x(k)));
t(k+1)=t(k)+h;
% Si queremos guardar tiempo hasta que T<40ºC
if flag == 1 && x(k)<=40
fprintf('T=40º en t=%f\n',t(k));
flag = 0;
end
k=k+1;
end

EJEMPLO EDO TIRO VERTICAL

%Ejemplo EDO Euler: proyectil que cae al suelo en vertical

%F=m*a
%-mg=m*(d^2x(t))/dt^2
%d^2x(t)/dt^2=-g
%x(0)=0
%dx(t)/dt)=vo=10 m/s en t=0

%Este problema no se puede plantear como el de la taza de café, ya que es

%de segundo orden, sino que habrá que plantearlo como un sistema de dos
%ecuaciones de primer orden

%----> dv(t)/dt=-g && dx(t)/dt=v(t)

%----> condiciones iniciales: x(0)=0; v(0)=vo;

%Ejemplo integración : proyectil que cae sin rozamiento

function ejemplo_edo_tiro_vertical
tfinal=input('tfinal '); %Instante de tiempo en el que queremos finalizar
la simulación
h=input('h= ');
[t,x]= Euler_II(tfinal,h);%Deberá devolver dos vectores, el del tiempo y
el de x
plot(t,T); %Gráfica
end

%-----------------------
function [t,x]=Euler_II(tfinal,h)
%Condiciones iniciales
t(1)=0; %Consideramos que el vector de tiempo comienza en 0
x(1)=0; %Condición inical en x(0), en MATLAB no podemos poner x(0) porque
no hay componente 0 de un vector
v(0)=10; %(m/s) Velocidad inicial
k=1;
flag=0;
% while t(k)<tfinal
while x(k)>=0 %Si tenemos otras condiciones que nos hagan parar antes
v(k+1)=v(k)+h*(-9.81)
x(k+1)=x(k)+h*(v(k));
t(k+1)=t(k)+h;
k=k+1;
end

EJEMPLO EDO TIRO VERTICAL ROZAMIENTO

%Ejemplo EDO Euler: proyectil que cae al suelo en vertical con rozamiento

%F=m*a
%-mg=m*(d^2x(t))/dt^2
%d^2x(t)/dt^2=-g
%x(0)=0
%(dx(t)/dt)=vo=10 m/s en t=0

%Este problema no se puede plantear como el de la taza de café, ya que es

%de segundo orden, sino que habrá que plantearlo como un sistema de dos
%ecuaciones de primer orden

%----> dv(t)/dt=-g-kf/m*v(t)*|v(t)| && dx(t)/dt=v(t)

%----> condiciones iniciales: x(0)=0; v(0)=vo;

%Ejemplo integración : proyectil que cae sin rozamiento

function ejemplo_edo_tiro_vertical_rozamiento
tfinal=input('tfinal '); %Instante de tiempo en el que queremos finalizar
la simulación
h=input('h= ');
[t,x]= Euler_II(tfinal,h);%Deberá devolver dos vectores, el del tiempo y
el de x
plot(t,T); %Gráfica
end

%-----------------------
function [t,x]=Euler_II(tfinal,h)
%Condiciones iniciales
t(1)=0; %Consideramos que el vector de tiempo comienza en 0
x(1)=0; %Condición inical en x(0), en MATLAB no podemos poner x(0) porque
no hay componente 0 de un vector
v(0)=10; %(m/s) Velocidad inicial
k=1;
flag=0;
% while t(k)<tfinal
while x(k)>=0 %Si tenemos otras condiciones que nos hagan parar antes
v(k+1)=v(k)+h*(-9.81-0.5/5*v(k)*abs(v(k))
x(k+1)=x(k)+h*(v(k));
t(k+1)=t(k)+h;
end
k=k+1;
end

EJEMPLO ORDENACIÓN BURBUJA

% 09/05/16

%Ordenación burbuja (Bubble sort)

%[4,-1,3,2], se comparan dos elementos y se ve si están en orden o no, en
%el ultimo caso, se reordena; se repite con todas las parejas posibles.
%Tras una primera pasada, el primer elemento coincidirá con el más
pequeño.

%Se hacen tantas pasadas -1 como elementos tenga el vector

%PASADA 1: n-1 comparaciones// PASADA 2: n-2 comparaciones// En cada

pasada
%realizamos una iteración menos

%Ordenación por el método de la burbuja

function ejemplo_ordenacion_burbuja
v=[4 -1 3 2];
v=ordena_burbuja(v);
disp(v);
end

function v=ordena_burbuja(v)
n=length(v);
i=1;
while i<=n-1 %Realizamos n-1 pasadas
for j-1:-1:i
if v(j)>v(j+1) %Si están fuera de orden
aux=v(j); %los intercambiamos
v(j)=v(j+1);
 v(j+)=aux;
end
end
i=i+1
end

EJEMPLO ORDENACIÓN BURBUJA II

% 09/05/16

%Ordenación burbuja (Bubble sort)

%[4,-1,3,2], se comparan dos elementos y se ve si están en orden o no, en
%el ultimo caso, se reordena; se repite con todas las parejas posibles.
%Tras una primera pasada, el primer elemento coincidirá con el más
pequeño.

%Se hacen tantas pasadas -1 como elementos tenga el vector

%PASADA 1: n-1 comparaciones// PASADA 2: n-2 comparaciones// En cada

pasada
%realizamos una iteración menos

%Ordenación por el método de la burbuja

function ejemplo_ordenacion_burbuja
%v=[4 -1 3 2];
v=randi([-10 10],1,10); %valores aleatorios para un vector de 10
componentes
v=ordena_burbuja(v);
disp(v);
end

function v=ordena_burbuja(v)
n=length(v);
i=1;
fin=1;%Reduce el número de iteraciones respecto al
ejemplo_ordenacion_burbuja
while i<=n-1 %Realizamos n-1 pasadas
fin=0; %Si se produce algún intercambio se volverá a poner en 1
for j=(n-1):-1:i
if v(j)>v(j+1) %Si están fuera de orden
aux=v(j); %los intercambiamos
v(j)=v(j+1);
v(j+1)=aux;
fin=1; % En caso de que haya un intercambio en la pasada nro
i,ponemos fin a 1
end
end
i=i+1;
end
end

EJEMPLO QUICKSORT

%09/05/16

%Quick sort
%v=[2 5 3 6 -1 8 4]
%pivote=v((i+j)/2); se comparan los valores del vector con el pivote,
%intercambiando si sus valores no están en el orden correcto.

% ATENCIÓN: floor redondea al entero más pequequeño y fix tan solo

trunca,
% la diferencia se observa en números negativos
%Ordenación QuickSort
function ejemplo_Quicksort
v=[2 5 3 6 -1 8 4];
L=length(v);
v=quicksort(v,1,L);
disp(v);
end

function v=quicksort(v,inicio,fin) %Función recursiva que ordena vector v

entre componente inicio y fin
i=inicio;
j=fin;
pos_pivote=fix((i+j)/2);
pivote=v(pos_pivote);
while i<=j
% Buscamos componentes mayores que el pivote a su izquierda
while v(i)<pivote
i=i+1;
end
% Buscamos componentes menores que el pivote a su derecha
while v(j)>pivote
j=j-1;
end
%Intercambiamos componentes i y j
if i<=j
aux=v(i);
v(i)=v(j);
v(j)=aux;
i=i+1;
j=j-1;
end
end
if inicio<j %Si la mitad inferior mide 2 o más componentes
v=quicksort(v,inicio,j); %Ordeno mitad inferior del vector
end
if i<fin %Si la mitad superior mide 2 o más componentes
v=quicksort(v,i,fin); %Ordeno mitad superior del vector
end
end

ES PALINDROMO

%Ejercicio 3.2: Determina si una cadena es palíndromo

function [r]=es_palindromo(cad)
cad_esp=sinEspacios(cad);
cad_may=mayusculas(cad_esp);
N=length(cad_may);
i=0;
j=N+1;
r=1;
while i<=j
i=i+1;
j=j-1;
if cad_may(i)~=cad_may(j);
r=0;
break
end
end
if r==1
disp('Es palíndromo');
else
disp('No es palíndromo');
end
end

function cad_esp=sinEspacios(cad)
N=length(cad);
k=0;
for i=1:N
if cad(i)~=' '
k=k+1;
cad_esp(k)=cad(i);
end
end
end

function cad_mayusc=mayusculas(cad)
N=length(cad);
for i=1:N
if cad(i)<='z' && cad(i)>='a'
cad_mayusc(i)=cad(i)+'A'-'a';
else
cad_mayusc(i)=cad(i);
end
end
end

ES PERFECTO

function [r]=esperfecto(n)
n=input('Introduzca n: ');
sum=0;
for i=1:n-1
if mod(n,i)==0
sum=sum+i;
end
end
if sum==n
r=1;
else
r=0;
end
end
FACTORIAL N

% Ejercicio 1.11: Factorial de n

n=input('Introduzca número: ');

fact=1;
for i=1:n
fact=fact*i;
end
disp(fact);

FACTORIAL N (SIN FUNCIONES)

% Factorial de un número n (sin funciones)

producto=1;
factor=2;
n=input('n= ');
for factor=2:n
producto=producto*factor;
end
factorial=producto;
disp(factorial);

FIBONACCI(EJEMPLO VBLES. PERSISTENTES)

%Ejercicio2.7: Sucesión de Fibonacci con cálculo de enesima mediante

fórmula
function t=fib_pers(n1,n2)
n=1;
m=input('Final de la sucesión: ');
while n<=m
fprintf('%d\n',n);
n=enesima(m);
end
end

function n=enesima(m)
a=(1+sqrt(5))/2;
b=(1-sqrt(5))/2;
pota=pot(a,m);
potb=pot(b,m);
n=(1/sqrt(5))*(pota-potb);
end

function [r]=pot(x,m)
r=1;
for i=1:m
r=r*x;
end
disp(r)
end
FIBONACCI (EJEMPLO I, SIN FUNCIONES)

%Ejercicio 2.7: Sucesión de Fibonacci sin funciones

function v=Fibonacci_ejercicio2
N=input('Introduzca límite de la sucesión: ');
anmdos=0;
anmuno=1;
an=1;
for i=1:N
v(i)=an;
an=anmuno+anmdos;
disp(an);
anmdos=anmuno;
anmuno=an;
end
end

FIBONACCI (EJEMPLO II, VBLES. LOCALES)

%Sucesión de Fibonacci con variables locales

function t=fib(n1,n2)
n=1; %inicialización de a(n)
m=input('Introducir fin de la sucesión: ');
n2=0; %inicialización de a(n-2)
n1=1; %inicialización de a(n-1)
while n<=m
fprintf('%d\n',n);
n=enesima(n1,n2); %cálculo del término enésimo
n2=n1;
n1=n;
end
end

function n=enesima(n1,n2)
n=n1+n2;
end

GOLDBACH

%Ejercicio 2.4: Conjetura de Goldbach

function goldbach
n=input('Introduzca número entero par mayor que dos: ');
v=[];
for i=1:n
m=n-i;
r=es_primo(m);
if r==1
q=es_primo(i);
if q==1
v(1)=m;
v(2)=i;
end
end
end
disp(v);
end

function [r]=es_primo(x)
r=1;
d=2;
while r==1 && d<x
if mod(x,d)==0
r=0; %En cuanto encuentra un valor por el cual es divisible
"deja de ser primo"
end
d=d+1;
end
end

GOLDBACH PRO

function goldbach_pro
%Esta función de Goldbach calcula todas las combinaciones posibles de
%números primos, cortesía de Adri
n=input('Introduzca número par mayor que dos: ');
k=0;
v=zeros;
for i=2:n
r=es_primo(i);
if r==1
k=k+1;
v(k)=i;
end
end
%Creamos otro vector que esté dado la vuelta idéntico al anterior
N=length(v);
for k=1:N
for j=N:-1:1
w(j)=v(k);
end
end
goldbach=lista_goldbach(w,v,n);
disp(goldbach);
end

function [goldbach]=lista_goldbach(w,v,n)
%Sumamos componente a componente para comprobar si dan el resultado n
N=length(v);
k=0;
goldbach=[];
for i=1:N
for j=i:N
if [v(i)+w(j)]==n
k=k+1;
goldbach(k,:)=[goldbach;[v(i) w(j)];
end
end
end
function [r]=es_primo(x)
r=1;
for i=2:n
if mod(x,i)==0
r=0;
break
end
end
end

IDENTIFICA SÍMBOLO

%Ejercicio 3.3: Identificación de símbolos en un texto

function identificaSimbolo(texto,simbolos)
N=length(texto);
M=length(simbolos);
i=1;
j=1;
while i<=M
cont=0;
pos=[];
while j<=N
if texto(j)==simbolos(i)
cont=cont+1;
pos=[pos,j];
end
j=j+1;
end
if cont==0
fprintf('Símbolo %s no aparece\n',simbolos(i));
else
n=length(pos);
for k=1:n
fprintf('Símbolo %s aparece en la posición
%d\n',simbolos(i),pos(k)); %Este algoritmo proporciona todas las
posiciones en las que se encuentra
end
end
j=1;
i=i+1;
end
end

IDENTIFICA SÍMBOLO 2

%Ejercicio 3.4: Identificador de símbolos en una cadena de texto.

Devuelve
%1 si está el símbolo en la cadena y 0 en caso contrario

function identificaSimbolo2(texto,simbolos)
N=length(texto);
M=length(simbolos);
i=1;
j=1;
r=1; %Suponemos inicialmente que no hay coincidencia alguna
for i=1:N
for j=1:M
if texto(i)==simbolos(j)
r=0;
end
end
end
end
disp(r);
end

INVIERTE CADENA

% Programa que lee una cadena y la devuelve invertida

function invierta_cadena
s=input('Cadena= ','s');
si=invertir(s);
fprintf('Cadena invertida=%s\n',si);
end

function si=invertir(s);
N=length(s);
j=N;
for i=1:N
si(j)=(s(i));
j=j-1;
end
end

LISTA DIVISIBLES 2 Y NO 3

% Ejercicio 1.5: Listado de números divisibles por 2 y no por 3

n=input('Introduzca n: ');
x=0;
for i=1:n
x=x+1;
if mod(x,2)==0
if mod(x,3)~=0
disp(x);
end
end
end

LISTA PRIMOS

%Mostrar lista de números primos entre 0 y 100

n=2;
cont=1;
while cont<100
d=2;
while mod(n,d)~=0
d=d+1;
 end
cont=cont+1;
if d==n
fprintf('%d\n',n);
end
n=n+1;
end

LISTADO NÚMEROS ABUNDANTES

%Ejercicio 1.16: Listado de números abundantes

N=input('Introduzca valor límite: ');
for n=1:N
sumat=0;
for i=1:n-1
if mod(n,i)==0
sumat=sumat+i;
end
end
if sumat>n
disp(n);;
end
end

LISTADO NÚMEROS PERFECTOS

%Ejercicio 2.3: Números perfectos

function listado_num_perf
N=input('Introduzca límite del listado: ');
n=0;
cont=0;
while cont<N
n=n+1;
r=esperfecto(n);
if r==1
disp(n);
cont=cont+1;
end
end
end

function [r]=esperfecto(n)
sum=0;
for i=1:n-1
if mod(n,i)==0
sum=sum+i;
end
end
if sum==n
r=1;
else
r=0;
end
end

MÍNIMO, MÁXIMO Y MEDIA DE UN VECTOR

%Ejercicio 2.1: Min,Max y media de un vector

v=input('Introduzca vector: ');

N=length(v);
v_max=v(1);
v_min=v(1);
sum=0;
for k=1:N
if v(k)>v_max
v_max=v(k);
end
if v(k)<v_min
v_min=v(k);
end
sum=sum+v(k);
end
med=sum/N;
fprintf('El valor máximo es %d\n',v_max);
fprintf('El valor mínimo es %d\n',v_min);
fprintf('La media de las componentes es %.2f\n',med);

MAYOR EDAD

% Ejercicio 1.2: Identificador de edades

x=input('Introduzca edad: ');

if x<18
disp('Menor de edad');
elseif x>=18 && x<65
disp('Mayor de edad');
else
disp('Jubilado');
end

MÍNIMO COMÚN MÚLTIPLO

%Ejercicio 1.17.1: Mínimo común múltiplo

x=input('Introduzca primer número: ');
y=input('Introduzca segundo número: ');
min=1;
if x>y
p=x;
else
p=y;
end
for i=2:p
n=1;
m=1;
while mod(x,i)==0
n=n*i;
end
 while mod (y,i)==0
m=m*i;
end
if m>n
min=m*min;
else
min=n*min;
end
end
disp(min);

MEDIA DE DOS NÚMEROS

% Cálculo de la media de a y b
a=input('Introduce a: ');
b=input('Introduce b: ');
c=(a+b)/2;
fprintf('media de a y b = %d\n',c);

MEDIA DE DOS NÚMEROS EN VALOR ABSOLUTO

%Ejercicio 1.1: Media de dos números en valor absoluto

function media_abs=media_abs(x,y)
x=input('Introduzca primer número: ');
y=input('Introduzca segundo número: ');
media=(x+y)/2;
media_abs=val_abs(media);
fprintf('La media es %.1f\n',media_abs);
end

function r=val_abs(x)
if x<0
r=-x;
else
r=x;
end
end

MEDIA ARITMÉTICA DE LAS COMPONENTES DE UN VECTOR

% Media aritmética de las componentes de un vector

function m=media_vect(v)
v=input('v= ');
n=length(v);
sumat=0;
for cont=1:n
sumat=v(cont)+sumat;
end
media=sumat/n;
fprintf('La media de las componentes es %d\n',media);
end
FACTORIAL DE UN NÚMERO

% Factorial de un número n (con funciones)

function factorial=mi_fact(n)
producto=1;
for factor=2:n
producto=producto*factor;
end
factorial=producto;

NORMA DE UN VECTOR

%Cálculo de la norma de un vector

function norma_vector
v=[1 2 3];
n=norma(v); %pasamos vector v a función norma
fprintf('|v|=%f\n',n);
end

function n=norma(v)
N=length(v); %tamaño del vector
s=0;
for i=1:N %recorremos las componentes del vector
s=s+v(i)*v(i);
end
n=sqrt(s); %raíz cuadrada
end

NORMA DE UN VECTOR PEDIDO ELEMENTO A ELEMENTO (EJEMPLO VBLES. GLOBALES)

%Norma del vector pedido elemento a elemento

function norma_vector
global N
N=input('Dimensión del vector: ');
v=vector;
n=norma(v);
fprintf('|v|=%f\n',n);
end

function v=vector
global N
for i=1:N
v(i)=input(sprintf('v(%d)= ',i));
end
fprintf('%f\n',v);
end

function n=norma(v);
global N
s=0;
for i=1:N;
s=s+v(i)*v(i);
end
n=sqrt(s);
end

NÚMERO ABUNDANTE

%Ejercicio 1.15: Determinar si un número es abundante

n=input('Introduzca número: ');
sumat=0;
for i=1:n-1
if mod(n,i)==0
sumat=sumat+i;
end
end
if sumat>n
disp('Es un número abundante');
else
disp('No es un número abundante');
end

NÚMERO COMBINATORIO (PARTE 1)

% Ejercicio 1.12(parte 1): número combinatorio

function num_combp1
n=input('n=');
m=input('m=');
if n>=m
n_fact=factorial(n);
nm_fact=factorial(n-m);
m_fact=factorial(m);
num_comb=n_fact/(nm_fact*m_fact);
end
fprintf('(n m)=%d\n',num_comb);
end

function fact=factorial(x);
fact=1;
for i=1:x
fact=fact*i;
end
end

OBJETO ÓPTIMO

%Ejercicio 4.1: Algoritmo Greedy

function objeto_optimo(OBJ,moch,Pmax)
%Calculamos el rendimiento de todas las filas
rend = rendimiento(OBJ);
M = length(rend);
N = length(moch);
max = zeros;
k = 1;
sum_moch = 0;
a = 0;
%Creamos un vector max que tiene las posiciones de las filas de la matriz
%ordenadas de mayor a menor rendimiento correspondiente
rend_max = rend(1);
for i = 1:M
k=i;
while rend_max <= rend(k)
rend_max = rend (k);
k=k+1;
end
max(i) = k - 1;
end
%Creamos la variable sum_moch
for j = 1:N
p = moch(j);
sum_moch = sum_moch + OBJ(p,1);
end
% Buscamos el la fila de OBJ que tenga máximo rendimiento sin superar
Pmax
if Pmax == sum_moch
disp('No caben más objetos en la mochila');
else
s = 1;
while Pmax > sum_moch
a = max(s)
sum_moch = sum_moch + OBJ (a,1);
s = s+1;
end
fprintf ('El objeto de mayor relación valor/peso que cabe en la
mochila es %d\n',a);
end
end

function [rend] = rendimiento(OBJ)

[m,~]=size(OBJ);
rend=zeros;
for i=1:m
rend (i) = OBJ(i,2)/OBJ(i,1);
end
end

ORDENA

function [v]=ordena(v)
v=[4 -1 3 2];
v=ordenacionBurbuja(v);
disp(v);
end

function [v]=ordenacionBurbuja(v)
n=length(v);
fin=1;
i=1;
while fin==1 && i<=n-1
fin=0;
for j=n-1:-1:i
if v(j)>v(j+1)
aux=v(j);
v(j)=v(j+1);
v(j+1)=aux;
fin=1;
end
end
i=i+1;
end
end

ORDENACIÓN INSERTA

% Algoritmo de ordenación por inserción

function ordenacion_insercion
v=[2 -3 4 -1 9];
v=ordena_insercion(v);
disp(v);
end

function vo=ordena_insercion(v)
L=length(v);
vo=[]; %Vector solución inicialmente vacío
%Vamos insertando cada componenente de v en vo mediante la función
inserta
for i=1:L
v=inserta(vo,v(i));
end
end

function v=inserta(v,x)
L=length(v);
i=1;
% Búsqueda del punto de inserción
while i<=L && x>v(i) % Mientras no me salga del vector y comparamos con
el valor de x cada valor del vector
i=i+1;
end
% Desplazamos componentes remanentes una posición hacia abajo. Empezamos
% por el últmo valor
j=L;
while j>=i
v(j+1)=v(j);
j=j-1;
end
v(i)=x;
end

ORDENACIÓN INSERCIÓN 2

function ordenacion_insercion2
v=[2 -3 4 -1 9];
v=ordena_insercion_directa(v);
disp(v);
end

function v=ordena_insercion_directa(v)
%Ordenación por insdrción sin necesidad de vector auxiliar
L=length(v);
for i=2:L
j=i;
aux=v(i);
while j>i && aux<v(j-1)
v(j)=v(j-1);
j=j-1;
end
v(j)=aux;
end
end

%COMPROBAR CUAL ES EL FALLO POR EL CUAL NO ME ORDENA EL VECTOR!!!!!

PALÍNDROMO

%Determinar si una columna de texto es palíndromo

function palindromo
cad=input('Introduce cadena: ','s');
r=espalindromo(cad);
%r=1 si es palíndromo y r=0 si no lo es
if r==1
disp('Es palíndromo');
else
disp('No es palíndromo');
end
end

function r=espalindromo(cad);
N=length(cad);
i=1;
j=N;
r=1; %supongamos que es palíndromo
while i<=j
if cad(i)~=cad(j)
r=0;
end
i=i+1;
j=j-1;
end
end

PALÍNDROMO MAYÚSCULAS

%Determinar si una columna de texto es palíndromo

function palindromo
cad=input('Introduce cadena: ','s');
cadmay=mayusc(cad);
r=espalindromo(cadmay);
%r=1 si es palíndromo y r=0 si no lo es
if r==1
disp('Es palíndromo');
else
disp('No es palíndromo');
end
end

function cadmay=mayusc(cad);
N=length(cad);
for i=1:N
if cad(i)>='a'& cad(i)<='z'
cadmay(i)=cad(i)+'A'-'a';
else
cadmay(i)=cad(i);
end
end
end

function r=espalindromo(cadmay);
N=length(cadmay);
i=1;
j=N;
r=1; %supongamos que es palíndromo
while i<=j
if cadmay(i)~=cadmay(j)
r=0;
end
i=i+1;
j=j-1;
end
end

PASA A BINARIO

%Ejercicio 2.6: Representar un número en base 2

function pasaBinario
n=input('Introduzca número en base decimal: ');
d=2;
k=0;
while n>0
k=k+1;
bin(k)=mod(n,d);
n=fix(n/d);
end
N=length(bin);
k=0;
for i=N:-1:1
k=k+1;
vect_bin(i)=bin(k);
end
disp(vect_bin);
end

PASA HEXADECIMAL

%Ejercicio 2.6: Representar un número en base hexadecimal

function pasaHexadecimal
n=input('Introduzca número en base decimal: ');
d=16;
k=0;
hexa='';
while n>0
k=k+1;
aux=mod(n,d);
n=fix(n/d);
if aux>9
aux='A'+aux-10;
else
aux = '0'+aux;
end
hexa(k)=aux;
end
N=length(hexa);
k=0;
for i=N:-1:1
k=k+1;
vect_hexa(i)=hexa(k);
end
disp(char(vect_hexa))
end

PRIMOS GEMELOS

%Ejercicio 2.5: Listado de números primos gemelos

function lista_gemelos
n=input('Introduzca valor límite: ');
i=1;
w=[];
for P1=1:n
for P2=1:n
r=pgemelos(P1,P2);
if r==1
t=esPar(i);
if t==0 %Si la posición no es par, entonces se introduce en
la matriz de primos gemelos
matrix_primos(i,1)=P1;
matrix_primos(i,2)=P2;
end
i=i+1;
end
end
P2=1;
end
[M N]=size(matrix_primos);
i=0;
for k=1:M
if matrix_primos(k,:)~=[0 0]
i=i+1;
matrix_gem(i,:) = matrix_primos(k,:);
end
end
disp(matrix_gem);
end

function [r]=pgemelos(x,y)
n=es_primo(x);
m=es_primo(y);
if n==1 && m==1 && x~=1 && y~=1%Comprobamos que ambos números son primos.
Añadimos la condición de que sean distintos a 1 ya que según la info
buscada el 1 no se incluye
res=x-y;
dist=vabs(res);
else
dist=0;
end

if dist==2
r=1;
else
r=0;
end

end

function [t]=esPar(i)
if mod(i,2)==0
t=1;
else
t=0;
end
end

function [r]=vabs(x)
if x<0
r=-x;
else
r=x;
end
end

function [r]=es_primo(x)
r=1;
d=2;
while r==1 && d<x
if mod(x,d)==0
r=0; %En cuanto encuentra un valor por el cual es divisible
"deja de ser primo"
end
d=d+1;
end
end

POTENCIA (EJEMPLO VBLES. PERSISTENTES)

function pot(3)
persistent pot
if isempty (pot)
pot=1;
end
persistent m
if isempty(m)
m=0;
end
for i=1:m
pot=pot*x;
end
end

POTENCIA DE X ELEVADO A Y

% Potencia de x elevado a y

function z=potenciap(x,y) %función para elevar x a la y

pot=x;
for i=2:y
pot=pot*x;
end
fprintf('%d\n elevado a %d\n es %d\n', x,y,pot);
end

PUNTOS DE SILLA

%Ejercicio 2.9: Identificación de puntos de silla

function pto_silla
M=input('Introduzca matriz: ');
pos_fila=busqueda_max_fila(M);
pos_col=busqueda_max_colum(M);
pos=[pos_fila;pos_col];
ptos_silla=busquedaPtosSilla(pos);
disp(ptos_silla);
end

function ptos_silla=busquedaPtosSilla(pos)
[m, ~]=size(pos);
ptos_silla=[];
a=0;
for i=1:m
v=pos(i,:);
for k=(i+1):m
if v==pos(k,:)
a=a+1;
ptos_silla(a,:)=v;
 end
end
end
end

function [matrix_pos1]=busqueda_max_fila(M)
[m, n]=size(M);
for j=1:m
max_fila=1;
for k=1:n
%Identificamos el elemento de mayor valor de cada fila
if M(j,k)>=max_fila
max_fila=M(j,k);
matrix_pos1(j,:)=[j,k];
end
end

end
end

function [matrix_pos2]=busqueda_max_colum(M)
[m, n]=size(M);
for k=1:n
max_col=1;
for j=1:m
%Identificamos el elemento de mayor valor de cada columna
if M(j,k)>=max_col
max_col=M(j,k);
matrix_pos2(k,:)=[j,k];
end
end
end
end

RECTÁNGULO DE ÁREA MÁXIMA Y PERÍMETRO LIMITADO

% Ejercicio 1.7: Rectángulo de área máxima y perímetro limitado (lados

% enteros)
Pmax=90;
while mod(Pmax,4)~=0
Pmax=Pmax-1;
end
L1=Pmax/4;
L2=L1;
P=L1*L2;
amax=L1*L2;
L1max=1;
L2max=1;
while P<=Pmax
L1=L1+1;
L2=L2-1;
a=L1*L2;
if a>amax
amax=a;
L1max=L1;
L2max=L2;
 end
end
fprintf('L1=%d\n',L1);
fprintf('L2=%d\n',L2);

RENDIMIENTO (GREEDY)

%Ejercicio 4.1: Algoritmo Greedy

function [rend] = rendimiento(OBJ)

[m,~]=size(OBJ);
rend=zeros;
for i=1:m
rend (i) = OBJ(i,2)/OBJ(i,1);
end
end

function [i]=obj_optimo(OBJ,moch,Pmax)
%Creamos un vector ordenado de mayor a menor valor
rend = rendimiento(OBJ);
N = length(rend);
rend_max = rend(1);
k = 1;
max=zeros;
for i = 1:N
if rend(i) > rend_max
rend_max = rend(i);
max(k) = rend(i);
k = k+1;
end
end
%Calculamos la suma de todos los pesos de los elementos que ya están en
la
%mochila; suponemos que el vector moch nos da la posición de cada objeto
%dentro de la matriz OBJ
L = length(moch);
sum_moch=0;
for k = 1:L
i = moch(k);
sum_moch = sum_moch + OBJ (i,1);
end
%Con cada componente, por orden, comprobamos si cabe en la mochila, hasta
%que así sea

if Pmax==sum_moch
disp('No caben más objetos en la mochila');
end
while Pmax < sum_moch
for i = 1:N
sum_moch = sum_moch + max(i);
end
end
fprintf('El objeto de mayor relación valor/peso que cabe en la mochila
está en la fila %d\n',i);
end
STARS MATRIX

% Ejercicio 1.13: Escribir matriz de asteriscos

n=input('Introducir número de asteriscos: ');

x='*';
y=' ';
while n>=1
for i=1:n
fprintf('%c',x);
end
n=n-1;
fprintf('%c\n',y);
end

STARS MATRIX 2

% Ejercicio 1.14: Figura de asteriscos (2)

n=input('Introducir el número de columnas (impar) de la figura: ');

m=input('Introducir el número de filas de la figura: ');
n=n-1;
m=m-1;
i=0;
j=n;
x='*';
y=' ';
k=1;
while k<=n
for m=i:j
fprintf('%s',x);
end
i=i+1;
j=j-1;
k=k+1;
fprintf('%s\n',y);
for p=1:i
fprintf('%s',y);
end
end

SUMA DE LOS COEFICIENTES DE UN NÚMERO

% Ejericio 1.8: Suma de los coeficientes de un número

n=input('Introduzca número: ');
m=10;
cont=1;
while fix(n/m)~=0
cont=cont+1;
m=m*10;
end
N=cont; %Dimensión del vector que queremos crear
m=(10^(N-1));
v=zeros;
i=0;
while m>=1
 i=i+1;
if i<=N
v(i)=fix(n/m);
n=n-v(i)*m;
end
m=m/10;
end
disp(v);
sum=0;
for i=1:N
sum=sum+v(i);
end
disp(sum);

SUMA LIMITADA

% Ejercicio 1.6: Límite de suma de números

n=input('Introduzca valor límite: ');

suma=0;
while suma<=n
x=input('Introduzca número entero: ');
suma=suma+x;
end

SUMA DE LAS POTENCIAS ENÉSIMAS

% Ejercicio 1.10: Suma de de las potencias enésimas

function sumat_pot
x=input('x=');
n=input('n=');
sumat_pot=sumatorio(x,n);
end

function sumat_pot=sumatorio(x,n)
sumat_pot=1; % Corresponde a x^0
for i=1:n
pot=potencia(x,i);
sumat_pot=sumat_pot+pot;
end
end

function pot=potencia(x,n)
pot=1;
for k=1:n
pot=pot*x;
end
end
TÉRMINO GENERAL FIBONACCI

%Ejercicio 2.7: Fibonacci usando la fórmula

function n=termino_general_fibonacci(x)
n=4;
a=(1+sqrt(5))/2;
b=(1-sqrt(5))/2;
A=pot(a,n);
B=pot(b,n);
n=(1/(sqrt(5))*(A-B));
end

function A=pot(a,n)
A=1;
for i=1:n
A=A*a;
end
end

VARIOS

function [cad] = varios(n)

cad=input('cad= ','s');
N=length(cad);
for i=1:N
%comprobamos si es impar
if mod(i,2)~=0 %Si i es impar, se transforma en mayúscula
cad(i)=cad(i)+'A'-'a';
else
cad(i)=cad(i);
end
end
end