Está en la página 1de 23

9.

- Diseña algoritmo del programa que determine el MCD de dos números enteros por el
algoritmo de Euclides: consiste en realizar divisiones sucesivas; en la primera división, se
toma como dividendo el mayor de los números y como divisor el otro; luego, el divisor y el
resto sirven respectivamente de dividendo y divisor de la siguiente división. El proceso termina
cuando se obtiene un resto nulo. Elm cd es entonces el penúltimo resto del algoritmo.

inicio
leer A, B
si (A>B) entonces
dividendo = A
divisor = B
si_no
dividendo = B
divisor = A
fin_si
resto = dividendo%divisor
mientras (resto<>0) hacer
dividendo = divisor
divisor = resto
resto = dividendo%divisor
fin_mientras
visualizar divisor
fin

10.- Diseñar el algoritmo del programa que determina si una palabra introducida por teclado es
palíndromo o no. Un palíndromo es una palabra que se lee igual en ambos sentidos, como por
ejemploradar

Inicio i=0 j=0


leer cad
mientras (cad[i] <> “\0”) hacer
i = i + 1
fin mientras
mientras ( i <> 0) hacer
cad_inv[j] = cad[i–1]
j = j + 1
i = i – 1
fin mientras
cad_inv [j] = ”\0 ”
si (cad == cad_inv ) entonces
visualizar “si es palindromo”
si_novisualizar “no es palindromo”
fin_si
fin

• En una clase de matemáticas me enseñaron (y se puede comprobar) que un número


es divisible entre 2, divisible entre 3, divisible entre 5, o primo.

Con esta regla se puede sacar un algoritmo muy sencillo para esto (los guiones bajos
son para hacer sangría nomás, es que no me pone los espacios al principio de la
linea):

Código:

inicio
leer n
si (n % 2 <> 0) entonces
_si (n % 3 <> 0) entonces
__si (n % 5 <> 0) entonces
___escribir "'n' es número primo"
__fin si
_fin si
fin si
escribir "'n' no es número primo".
fin

y de hecho podrías ponerlo en una sola sentencia if en caso de que solamente quieras
determinar si es primo o no. Por ejemplo en C/C++:

Código:

if ( (n%2) || (n%3) || (n%5) )


cout<<"El número no es primo"
else
cout<<"El número no es primo";
si un numero es primo o no
• C = sqrt N (siendo C un entero)

• Si C <= 1 ------> Sale e indica que es primo.

• X = N % C (X es el residuo de la division)

• Si X > 0 ------> Sale e indica que no es primo.

• C = C - 1 y vuelve donde verifica si C <= 1
Aqui va el Pseudocodigo:

Begin

a -> int
b -> int
c -> int
temporal -> int
vec [3] -> int
Print "Por favor digite el primer número"
read a
vec [0] = a
Print "Por favor digite el segundo número"
read b
vec [1] = b
Print "Por favor digite el tercer número"
read c
vec [2] = c

if ( a = b ^ b = c) do
Print "Los tres números ingresados son iguales"
else
if ( vec [0] < vec [1]) do
temporal = vec [1]
vec [0] = vec [1]
vec [1] = temporal
else
if ( vec [1] < vec [2]) do
temporal = vec [1]
vec [1] = vec [2]
vec [2] = temporal

end if

Print "El valor más grande es:" + Vec[0] + "Y el menor valor es:" + Vec [2]

End

Te explico de que se trata....

1. Primero pide al usuario los números y los almacena en una variable ya sea a,
b o c y a su vez los envia a un vector para luego ordenarlos y verificar cual es
el mayor y cual el menor.

2. Luego analiza si el primer número del vector es mayor al segundo, de ser asi
simplemente asigna el segundo a una variable temporal e invierte los números
enviando el de la segunda casilla a la primera y el de la primera que ahora está
en una variable a la segunda

3. De no ser mayor el primero que el segundo entonces entra por el else y


analiza lo mismo de arriba pero con la casilla 2 y 3, si el número de la segunda
casilla es mayor al de la tercera solo los invierte de la misma forma que
explique arriba sino los deja igual.

4. Luego de esto tendras en las 3 casillas del vector los 3 números ordenados
de mayor a menor lo unico que falta es decirle que le imprima al usuario el
primer número que es el mayor y el ultimo que seria el menor

PD: Para analizar si son iguales solo se usa una regla matematica que dice que
si a = b y b = c entonces a = c

Else =además

Print=Impresión

int numero= 787; //Ingresa Numero a invertir

int cociente=numero;

int resto;

String inverso=”";

int contador=0;

int div = 1;

for(contador=0;cociente!=0;contador++){

// Sacamos el divisor multiplicandolo por 10 cada ves que cuente

div = div * 10;

//Formula

resto = ((numero % div)-(numero % (div/10) ))/ (div/10);

// Convertimos resto en String para concatenarlo

inverso += String.valueOf(resto);

//Restamos el cociente

cociente=cociente/10;

//Mostramos numero al REVES

System.out.println(“Inverso: ” + inverso);

esto el lo mejor

public class NumInverso {

public static void main(String args[]){

//Declaracion

int u,d,c,num,numInv,aux;

//Ingreso

num=321;
//Proceso

aux=num;

c= num/100;//4

num=num%100;

d=num/10;

u=num%10;

numInv=u*100+d*10+c;

//Salida

System.out.println(“El numero inverso es:”+numInv);

1. // Vector donde estan almacenados los numeros de los que se hallara su MCD
2. Entero[] vector
3. // Obtenemos el menor elemento del vector, el cual sera el maximo valor
por el que dividiremos cada elemento del vector.
4. Entero menor = MenorElemento( vector )
5. // Menor de todos los exponentes del factor primo actual
6. Entero menorExponente = 0
7. // Valor que almacena el MCD divisor de los numeros
8. Entero MCD = 1
9. // Indica si el factor primo actual es un divisor comun de todos los
numeros
10. Booleano esDivisorComun
11.
12. // "i", indica el factor que verificaremos si es factor comun ( divisor ) a
todos los numeros
13. Para i desde 2 hasta i*i <= menor hacer
14.
15. esDivisorComun = verdad
16. j = 1
17. menorExponente = 0
18.
19. Mientras( esDivisorComun )
20. Si( j = n + 1 ) // Si el divisor "i", es comun a todos
entonces el menorExponente aumenta 1
21. menorExponente = menorExponente + 1
22. j = 1
23.
24. // Como el i es divisor comun, pasamos a dividir todos los
numeros entre i,
25. // esto tambien afecta a "menor"
26. Para h de 1 hasta n hacer
27. vector[ h ] = vector[ h ] / i
28. FinPara
29.
30. menor = menor / i
31. FinSi
32.
33. Si( vector[ i ] mod i != 0 ) // Si el divisor actual no es
comun a todos, pasamos al siguiente divisor
34. esDivisorComun = falso
35.
36. Fin_Mientras
37.
38. // Actualizamos el MCD
39. MCD = MCD * Potencia( i, menorExponente )
40.
41. Fin_Para
42. Entero MCD = 1;
43.
44. // MaximoComunDivisor( a, b ) es el algoritmo de euclides usado para
45. // hallar el Maximo Comun Divisor de dos enteros positivos.
46. Para i de 2 hasta n hacer
47. MCD = MaximoComunDivisor( MCD, x[i] )
48.
49. Retornar MCD
50. Descripción
51. Sean n1 y n2 los números para calcularles el mcd
52. Mediante la sentencia Input se pide al usuario que los introduzca en la
Classpad
53. Establecemos un bucle que se va a repetir mientras n1≠n2 con While n1≠n2
54. Si n1>n2 entonces introducimos en n1 la diferencia n1-n2
55. y al contrario si n2>n1
56. El bucle termina cuando n1=n2
57. Al final con la orden PrintNatural sacamos en pantalla el resultado que será n1
(o bien n2)
58. Justificación matemática
59. Llamemos mcd al máximo común divisor de n1 y n2
60. n1= mcd . p (1)
61. n2= mcd . q (2)
62. Es decir n1 Ξ n2 (mod. mcd)
63. Se lee n1 y n2 son congruentes módulo mcd y significa que
64. dan el mismo resto al dividirlos por mcd, en este caso 0.
65. ----
66. Hacemos (1) - (2)
67. n1 - n2= mcd (p-q)
68. Con lo cual la diferencia de n1 con n2 será también un múltiplo de mcd.
69. Ahora nos quedamos con esta diferencia y con el menor de los dos números
iniciales n1 y n2
70. (asignamos de nuevo esa diferencia al mayor de n1 y n2)
71. Así vamos obteniendo dos números n1 y n2 que son múltiplos de mcd.
72. Continuamos el proceso hasta que ambos números sean iguales
73. que será el caso en que ambos sean igual al mcd multiplicado por 1,
74. con lo cual cualquiera de ellos es igual al mcd de ambos.
75. (es lógico, puesto que el mcd de un nº es él mismo)
76.
77. Si queremos hallar el mcd de varios números, por ejemplo n1,n2 y n3
78. hacemos primero el mcd de n1 y n2
79. y luego el de n3 con el resultado anterior.
80.Programa para calcular el mínimo común múltiplo de dos números.
81. (es una modificación del anterior en el que se aplica la relación
82. entre el mcd y el mcm con el producto de dos números)
83. Sean a y b dos números,
84. su mcm (a,b) = a . b / mcd (a,b)
85.
86. aún no lo has hecho, te recomiendo que repases la parte que he dedicado a
Fibonacci
87. y el nº de oro. La puedes encontrar aquí:
88. Fibonacci y el nº de oro
89. Allí propongo una función llamada fibo(n) para calcular cualquier nº de la
sucesión
90. de Fibonacci mediante una fórmula ideada por el matemático francés Binet y en
la
91. que interviene el nº de oro.
92. Aquí voy a afinar un poco la función fibo(n) que tenía algunos pequeños fallos
93. como no dar bien el resultado para fibo(1).
94. Para no tener que eliminar la función fibo(n) que tenemos almacenada
95. en la Classpad, he denominado a la nueva función pisa(n) en honor
96. de la ciudad natal de Leonardo de Pisa "Fibonacci".

97.
98. Recuerda que para que se quede almacenada y la puedas utilizar
99. mediante la pestaña Cat de la Classpad, tienes que anteponer library\
100. al nombre de la función cuando la definas:

101.
102. Utilizando la nueva función y la notación sigma (para realizar
sumatorios)
103. podemos comprobar una de las numerosísimas propiedades de la
sucesión
104. de Fibonacci:
105. "La suma de los n primeros elementos de la sucesión más la
unidad es
106. igual al elemento de lugar n+2"
107.

Cual es el mayor de tres números

INICIO

ingrese primer numero (n1)


leer (n1)

ingrese segundo numero (n2)


leer (n2)

ingrese tercer numero (n3)


leer (n3)

Si (n1) > (n2) y (n3) entonces


imprimir "el numero mayor es:" (n1)

sino
(n2) > (n1) y (n3)
imprimir "el numero mayor es:" (n2)

sino
imprimir "el numero mayor es:" (n3)
fin si

FIN

varriables n1, n2, n3, mayor, menor tipo etero


Inicio
escribe "Ingresa 1er numero"
lee n1
escribe "Ingresa 2do numero"
lee n2
escribe "Ingresa 3er numero"
lee n3
mayor = n1
if n2 > mayor
mayor = n2
fin_si
if n3 > mayor
mayor = n3
fin_si
menor = n1
if n2 < menor
menor = n2
fin_si
if n3 < menor
menor = n3
fin_si
escribe "Numero mayor: ",mayor
escribe "Numero menor: ",menor
Fin

Proceso Mayor
Escribir 'Ingrese el primer numero: ';
Leer Numero1;
Escribir 'Ingrese el segundo numero: ';
Leer Numero2;
Escribir 'Ingrese el tercer numero: ';
Leer Numero3;
Si (Numero1>Numero2) Entonces
Si (Numero1>Numero3) Entonces
mayor<-Numero1;
Si (Numero2>Numero3) Entonces
menor<-Numero3;
Sino menor<-Numero2;
FinSi
Sino mayor<-Numero3;
menor<-numero2;
FinSi
Sino Si (Numero2>Numero3) Entonces
mayor<-Numero2;
Si (Numero3>Numero1) Entonces
menor<-Numero1;
Sino menor<-Numero3;
Finsi
Sino mayor<-Numero3;
menor<-Numero1;
FinSi
Finsi
Escribir 'Mayor: ',mayor;
Escribir 'Menor: ',menor;
FinProceso

• inicio
leer a,b,c
si(a>b)y(a>c)entonces
max=a
si(b>a)y(b>c)entonces
max=b
si(c>a)y(c>b)entonces
max=c
imprimir "El número mayor es: max"
fin si
en caso contrario
imprimir "Los numeros son iguales"
fin

el menor de
tres números
La serie de fibonacci

#include <iostream>

int main (int argc, char * const argv[]) {


int i,n,fib,fib1,fib2,fibx;

std::cout<<"Un numero entero:";


std::cin>>n;
fib1=2; fib2=1; i=3;
if((n==1)||(n==2))
fib=1;
else{
do{
fib = fib1 + fib2;
fibx = fib1; i++;
fib1 = fib; fib2 = fibx;
}while(i<n);
}
std::cout << "\nEl "<<n<<"-esimo numero de
la serie Fibonacci es: "<<fib;
return 0;

La definición recursiva para encontrar todos los primeros números de la serie Fibonacci
es:
En el siguiente código, la solución que propone la recursividad resulta en una programación
elegante, aunque costosa. El código que hace esto es:

( 1) #include <iostream>
( 2) //====================
( 3) int fib(int val){
( 4) if ((val==1)||(val==2))
( 5) return 1;
( 6) else
( 7) return (fib(val-1)+fib(val-2));
( 8) }
( 9) //====================
(10) int main (int argc, char * const argv[]) {
(11) int n;
(12) std::cout<<"Numero entero:"; std::cin>>n;
(13) std::cout<<"\nEl "<< n
(14) <<"-esimo numero fibonacci es: "<< fib(n);
(15) return 0;
(16) }

Conversión de un numero en base 10 o en otra base

import javax.swing.JOptionPane;
public class Aplicacion
{
public static void main(String[] args)
{
int numero =
Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese el número
a transformar"));
int base =
Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese la base"));
Base bases = new Base(numero,base);
bases.transformar();
JOptionPane.showMessageDialog(null,"El número "+numero+" en base
"+base+"
es:\n"+bases.getResultado());
}
}

class Base
{
String equivalente;
int posicion;
int numero;
int base;
int[] digitos;
int[] auxiliar;

public Base(int n, int b)


{
posicion = 0;
equivalente = "";
base = b;
numero = n;
digitos = new int [1];
}

public void transformar()


{
if(numero<base)
{
digitos[posicion]=numero;
tamaño();
}
else
{
digitos[posicion]=numero%base;
tamaño();
posicion++;
numero = numero/base;
transformar();
}
}

public String getResultado()


{
for (int j = digitos.length-2; j >= 0; j--)
{
equivalente+=Character.toUpperCase(Character.forD
igit(digitos[j], 16));
}
return equivalente;
}

private void tamaño()


{
auxiliar = digitos;
digitos = new int [auxiliar.length+1];
System.arraycopy(auxiliar, 0, digitos, 0,
auxiliar.length);
}
}

= Descripción del código =

En la Clase Aplicación se piden los datos de entrada y se muestran los


resultados finales.
El constructor de la clase Base inicializa e instancia todas las
variables y los objetos de esta.
El método transformar se encarga de la función principal la cual es
llevar el numero ingresado en base diez a la base que hemos pedido en un
principio.
A medida que vamos encontrando un digito del nuevo número se almacena en
una casilla del Array digitos el cual por medio del método tamaño va
incrementando su capacidad de almacenamiento de uno en uno con ayuda del
Array auxiliar.
Por último se necesita ordenar los digitos en un String para mostrarlos
en el orden que es ya que en el Array digitos estos se encuentran de
atrás hacia adelante eso si teniendo en cuenta que cuando la base es
mayor a diez los digitos {10,11,12,13,14,15} se deben reemplazar por las
letras {A,B,C,D,E,F} respectivamente.

= Orden de complejidad =

Este Algoritmo presenta un orden de complejidad O(log (n))

= Pruebas =

{| {{tablabonita}}
|+ '''Ejemplos'''
|-
! Numero!! Base!!Resultado

|-
|10||2||1010
|-
|10||8||12
|-
|16||16||10
|-
|15455456||2||111010111101010011100000
|-
|-
|1089978205||16||40F7BF5D
|-
|35655||9||53816
|-
|-
|554455||2||10000111010111010111
|-
|}

= Forma de compilar y ejecutar =

Se puede compilar y ejecutar en cualquier IDE que reconozca lenguaje JAVA


como lo es el JCREATOR o el ECLIPSE en cualquiera de sus versiones. Para
ejecutarlo se debe crear un proyecto que contenga estas dos
clases(Aplicación, Base) y en ellas copiar el código que aparece
anteriormente.

= Conclusiones =

→ Se puede concluir primero que todo que la programación dinámica es


buena porque nos ayuda a evitar la repetición de cálculos y procesos.

→ Un problema bien solucionado algorítmicamente no tiene limitaciones,


como si las tiene una solución mecánica que solo se adapta a unos casos
específicos.

Otro ejemplo:
#include "iostream"
#include "conio.h"

using namespace std;

char* decimal_base(int N,int base)


{
// buffer que almacena el resultado
char* cad=new char[20];
//validar que la base este en el intervalo establecido
if(base<2||base>16)
return NULL;
else
{
//contador de numero
int i=0;
//vector para almacenart los digitos del numero
int n[20];
//descompone el numero en sus respectivos digitos segun la base
while(N>0)
{
n[i]=N%base;
N=N/base;
i++;
}
i--;
//contador de resultado
int j=0;
//convertir los digitos mayores a 10, en una letra del alfabeto
while(i>=0)
{
if(n[i]>=0&&n[i]<=9)
{
cad[j]=char(n[i]+48);
}
else
{
switch(n[i])
{
case 10:cad[j]='A';break;
case 11:cad[j]='B';break;
case 12:cad[j]='C';break;
case 13:cad[j]='D';break;
case 14:cad[j]='E';break;
case 15:cad[j]='F';break;
}
}
i--;
j++;
}
cad[j]='\0';
}
return cad;
}

int main(int argc, char *argv[])


{
int N,B;
cout<<"Ingrese numero en base 10 a convertir: ";
cin>>N;
cout<<"Ingrese base (2,...,16):";
cin>>B;
cout<<"Su correspondiente en base "<<B<<" es:"; cout<<decimal_base(N,B);

cout<<endl;
system("PAUSE");
return 0;

Otro ejemplo:

import javax.swing.JOptionPane;

public class bases {

public static String decimal_base(int N,int base)


{
// buffer que almacena el resultado
String cad="";
//validar que la base este en el intervalo establecido
if(base<2||base>16)
return "";
else
{
//contador de numero
int i=0;
//vector para almacenart los digitos del numero
int[] n=new int[20];
//descompone el numero en sus respectivos digitos segun la base
while(N>0)
{
n[i]=N%base;
N=N/base;
i++;
}
i--;
//contador de resultado
int j=0;
//convertir los digitos mayores a 10, en una letra del alfabeto
while(i>=0)
{
if(n[i]>=0&&n[i]<=9)
{
cad+=""+n[i];
}
else
{
switch(n[i])
{
case 10:cad+='A';break;
case 11:cad+='B';break;
case 12:cad+='C';break;
case 13:cad+='D';break;
case 14:cad+='E';break;
case 15:cad+='F';break;
//puedes seguir aumentado
}
}
i--;
j++;
}
}
return cad;
}

public static void main(String args[])


{
String cad="";
int N,B;

cad=JOptionPane.showInputDialog("Ingrese numero en base 10 a


convertir:", "");
N=Integer.parseInt(cad);

cad=JOptionPane.showInputDialog("Ingrese base (2,...,16):", "");


B=Integer.parseInt(cad);

JOptionPane.showMessageDialog(null,"Su correspondiente en base "+B+"


es: "+decimal_base(N,B));
}
}

sabemos representar a un número en base 10 cuando está en cualquier otra base, ahora
veremos el paso contrario; esto es, si está en base 10 convertirlo a una base b.

Si observamos las actividades que realizan los niños en primaria para comprender el
sistema decimal, podemos ver que una de ellas es separar en decenas una cantidad de
objetos.

Para convertir a cualquier base es exactamento lo que vamos a hacer pero reparando o
dividiendo entre b que es la base.

Ejemplo: Queremos convertir el número 47 a base 5.

Si separamos 47 objetos ‘por ejemplo piedras’ y las separamos de 5 en 5 tenemos 9


montones y sobran 2
si agrupamos a su vez los nueve montones de 5 en 5 obtenemos 1 y sobran 4

Esto nos dá la idea de que si multiplicamos {$ \large 1 \times 25 $} nos da 25


si multiplicamos {$ \large 4 \times 5 $} obtenemos 20
si sumamos las dos cantidades anteriores con 2 que es {$ \large 2 \times 1 $}

obtenemos 25 + 20 + 2 que es precisamente el resultado de una representación en base


5.

Esto es: {$ \large 1 \times 5^2 + 4 \times 5^1 + 2 \times 5^0 $} por lo que la
representación en base 5 es 1425
Podemos construir una tabla empezando con el número que queremos convertir en la parte
superior izquierda, dividimos entre la base b y colocamos el cociente abajo y el residuos a
la derecha, aplicamos sucesivamente este procedimiento hasta que el cociente es 0.

Los caracteres de la derecha forman la representación en base b que buscamos, de abajo


hacia arriba.

El ejemplo anterior quedaría:

47 2
9 4
1 1
0

Conversión de Decimal a Binario


El mismo algoritmo anterior con b = 2.

Ejemplo 1: Convertir a binario 49


49 1
24 0
12 0
6 0
3 1
1 1
0

Por lo tanto 49= 1100012

Ejemplo 2. Convertir 123 a binario:


123 1
61 1
30 0
15 1
7 1
3 1
1 1
0

Por lo tanto 123= 11110112

Ejemplo 3. Convertir 540 a binario:


540 0
270 0
135 1
67 1
33 1
16 0
8 0
4 0
2 0
1 1
0

Por lo tanto 540= 10000111002

Conversión de Decimal a Octal

Ejemplo 1: Convertir 381 a base 8.


381 5
47 7
5 5
0

Por lo tanto 381= 575 8

Ejemplo 2: Convertir 1072 a base 8.


1072 4
121 1
15 7
1 1
0

Por lo tanto 1072= 1714 8

Ejemplo 3: Convertir 42730 a base 8.


49711 1
6213 7
776 0
97 1
12 4
1 1
0

Por lo tanto 49711= 41047 8

Conversión de Decimal a Hexadecimal


Similarmente para convertir un número en base 10, a base 16 dividimos entre 16 aplicando
el algoritmo que se utilizó en base 2 y en base 8, en este caso si el residuo es mayor de 9 se
utilizan las letras A, B, C, D, E y F.

Ejemplo 1: Convertir 4325 a base 16.

4325 5
270 E
16 0
1 1
0
Por lo tanto 4325= 10E5 16

\\Analizaremos en general como convertir de una base b arbitraria a base 10 y viseversa. asi
por ejemplo:

450267= 4*744+5*73+0*72+6*70=4*2401+5*343+0*49+2*7+6=11339

Asi es para convertir de una base b a base 10 basta con aplicar la definicion.

Para convertir de base 10 a una base b solamente debemos de aplica el proceso contrario, es
decir dividir.

como se explica en los ejemplos de arriba.