Proyecto Algoritmos
PROYECTO ALGORITMOS PROGRAMAS EN PSEINT
Desarrollo y Creacion de Programas de Algoritmo en Psein: BRUJULADEARREGLO
este programa es un progreso de arreglo de brujula para saber si los arreglo de la unicacion en ordencomo para saber si ay o no ay arreglo de diferentes cosas o llegadas de un definicion como consultar ingreso motificaciones elimiar o salida de diferentes arreglos de cada posicion o proceso de diferencias de un eliminacion o salida de diferentes posiciones de conexion de un modificacion menu ingresos o consulta de difinicon.
//Eladorado por: Espinales Garcia Cristhian
Algoritmo brujuladearreglo
Definir N Como Entero
Definir opcMenu Como Caracter
Definir salir Como Logico
Escribir "Dimensión del arreglo: " Sin Saltar
Leer N
Si N>0 Entonces
Dimension A[N]
Definir A Como Cadena
salir <- Falso
Repetir
Escribir ""
Escribir " MENÚ"
Escribir "------------"
Escribir "(1) Ingresar"
Escribir "(2) Consultar"
Escribir "(3) Modificar"
Escribir "(4) Eliminar"
Escribir "(5) Salir"
Escribir "Elija una opción (1 al 5)...." Sin Saltar
Leer opcMenu
Borrar Pantalla
Segun opcMenu Hacer
'1':
ingresar(A, N)
teclaYBorrar
'2':
Escribir "Posición: " Sin Saltar
Leer pos
consultar(A, N, pos)
teclaYBorrar
'3':
Escribir "Posición: " Sin Saltar
Leer pos
modificar(A, N, pos)
teclaYBorrar
'4':
Escribir "Posición: " Sin Saltar
Leer pos
eliminar(A, N, pos)
teclaYBorrar
'5':
salir <- Verdadero
De Otro Modo:
Escribir "Opción incorrecta"
teclaYBorrar
FinSegun
Hasta Que salir
SiNo
Escribir "La dimensión del arreglo tiene que ser mayor que cero"
FinSi
FinAlgoritmo
Funcion ingresar(arreglo Por Referencia, final)
Definir i Como Entero
Escribir "Dimensión del arreglo = ", final
i<-1
Repetir
Si arreglo[i]=="" Y i<=final Entonces
Escribir ""
Escribir "Ingresar número en la posición ", i, ": " Sin Saltar
Leer arreglo[i]
i<-final+1
SiNo
Si i==final Entonces
Escribir ""
Escribir "Se ha llenado el arreglo, no hay más huecos"
i<-final+1
SiNo
i<-i+1
FinSi
FinSi
Hasta Que i>final
FinFuncion
FinFuncion
EJECUCIONES:
2.-MENUDEBASE:
Este programa nos permite sabes si un numero es un binacio o no octal vicecersa hexadecimal
por diferentes fuciones de una base o menu de diferentes numero para una difinicion de binarios o diferentes numrero.
Algoritmo menudeBase
Definir opcMenu Como Entero
Definir salir Como Logico
salir <- Falso
Repetir
Escribir " MENU"
Escribir "------------------------------------------"
Escribir "(1) De binario a octal y vicecersa"
Escribir "(2) De octal a hexadecimal y viceversa"
Escribir "(3) De binario a hexadecimal y viceversa"
Escribir "(4) Salir"
Escribir "Elija una opción...." Sin Saltar
Leer opcMenu
Borrar Pantalla
Segun opcMenu Hacer
1:
opcion1
2:
opcion2
3:
opcion3
4:
salir <- Verdadero
De Otro Modo:
Escribir "Opción incorrecta. Inténtelo de nuevo"
FinSegun
Hasta Que salir
FinAlgoritmo
Funcion opcion1
Definir opc Como Entero
Definir volver Como Logico
Definir num Como Cadena
volver <- Falso
Mientras !volver
Escribir " CONVERTIR"
Escribir "------------------------------"
Escribir "(1) De binario a octal"
Escribir "(2) De octal a binario"
Escribir "(3) Volver al menú anterior"
Escribir "Eligir opción (1 al 3)...." Sin Saltar
Leer opc
Borrar Pantalla
Segun opc Hacer
1:
Escribir "NÚMERO EN BINARIO: " Sin Saltar
Leer num
Si esBinario(num) Entonces
Escribir "Es ", deBinarioAOctal(num), " en octal"
SiNo
Escribir "No es un número binario"
FinSi
teclayBorrar
2:
Escribir "NÚMERO EN OCTAL: " Sin Saltar
Leer num
Si esOctal(num) Entonces
num <- quitarCeros(num)
Escribir "Es ", deOctalABinario(num), " en binario"
SiNo
Escribir "No es un número octal"
FinSi
teclayBorrar
3:
Borrar Pantalla
volver<-Verdadero
De Otro Modo:
Escribir "Opción incorrecta. Inténtelo de nuevo"
teclayBorrar
FinSegun
FinMientras
FinFuncion
Funcion opcion2
Definir opc Como Entero
Definir volver Como Logico
Definir num Como Cadena
volver <- Falso
Mientras !volver
Escribir " CONVERTIR"
Escribir "------------------------------"
Escribir "(1) De octal a hexadecimal"
Escribir "(2) De hexadecimal a octal"
Escribir "(3) Volver al menú anterior"
Escribir "Eligir opción (1 al 3)...." Sin Saltar
Leer opc
Borrar Pantalla
Segun opc Hacer
1:
Escribir "NÚMERO EN OCTAL: " Sin Saltar
Leer num
Si esOctal(num) Entonces
num <- quitarCeros(num)
Escribir "Es ", deOctalAHexadecimal(num), " en hexadecimal"
SiNo
Escribir "No es un número octal"
FinSi
teclayBorrar
2:
Escribir "NÚMERO EN HEXADECIMAL: " Sin Saltar
Leer num
Si esHexadecimal(num) Entonces
num <- quitarCeros(num)
Escribir "Es ", deHexadecimalAOctal(num) " en octal"
SiNo
Escribir "No es un número hexadecimal"
FinSi
teclayBorrar
3:
Borrar Pantalla
volver<-Verdadero
De Otro Modo:
Escribir "Opción incorrecta. Inténtelo de nuevo"
teclayBorrar
FinSegun
FinMientras
FinFuncion
Funcion opcion3
Definir opc Como Entero
Definir volver Como Logico
volver <- Falso
Mientras !volver
Escribir " CONVERTIR"
Escribir "------------------------------"
Escribir "(1) De binario a hexadecimal"
Escribir "(2) De hexadecimal a binario"
Escribir "(3) Volver al menú anterior"
Escribir "Eligir opción (1 al 3)...." Sin Saltar
Leer opc
Borrar Pantalla
Segun opc Hacer
1:
Escribir "NÚMERO EN BINARIO: " Sin Saltar
Leer num
Si esBinario(num) Entonces
Escribir "Es ", deBinarioAHexadecimal(num), " en hexadecimal"
SiNo
Escribir "No es un número binario"
FinSi
teclayBorrar
2:
Escribir "NÚMERO EN HEXADECIMAL: " Sin Saltar
Leer num
Si esHexadecimal(num) Entonces
num <- quitarCeros(num)
Escribir "Es ", deHexadecimalABinario(num) " en binario"
SiNo
Escribir "No es un número hexadecimal"
FinSi
teclayBorrar
3:
Borrar Pantalla
volver<-Verdadero
De Otro Modo:
Escribir "Opción incorrecta. Inténtelo de nuevo"
teclayBorrar
FinSegun
FinMientras
FinFuncion
Funcion teclayBorrar
Escribir "Pulse una tecla para continuar...."
Esperar Tecla
Borrar Pantalla
FinFuncion
Funcion OK <- esBinario(cad)
Definir OK Como Logico
Definir i Como Entero
OK <- Falso
// Comprobar que la cadena recibida está compuesta solo de ceros y unos
Para i<-1 Hasta Longitud(cad) Con Paso 1 Hacer
Si Subcadena(cad,i,i)=='1' O Subcadena(cad,i,i)=='0' Entonces
OK <- Verdadero
SiNo
// Si encuentra un caracter que no es un 1 o un 0 sale del bucle
OK <- Falso
i <- Longitud(cad)
FinSi
FinPara
FinFuncion
Funcion OK <- esOctal(cad)
Definir OK Como Logico
Definir i Como Entero
Definir C Como Caracter
valoresOctal <- "01234567"
OK <- Falso
// Comprobar que la cadena recibida está compuesta solo por dígitos del 0 al 7
Para i<-1 Hasta Longitud(cad) Con Paso 1 Hacer
C <- Subcadena(cad,i,i)
Para j<-1 Hasta 8 Con Paso 1 Hacer
Si C==Subcadena(valoresOctal,j,j) Entonces
OK <- Verdadero
j<-8 // Si encuentra el número, sale del bucle
SiNo
// Si cad tiene un dígito que no forma parte de la base octal
// sale del bucle y devuelve falso
Si (j==8) Entonces
OK <- Falso
i<-Longitud(cad)
FinSi
FinSi
FinPara
FinPara
FinFuncion
Funcion OK <- esHexadecimal(cad)
Definir OK Como Logico
Definir i Como Entero
Definir C Como Caracter
valoresOctal <- "0123456789ABCDEF"
OK <- Falso
// Comprobar que la cadena recibida está compuesta solo por dígitos del 0 al F
Para i<-1 Hasta Longitud(cad) Con Paso 1 Hacer
C <- Subcadena(cad,i,i)
Para j<-1 Hasta 16 Con Paso 1 Hacer
Si Mayusculas(C)==Subcadena(valoresOctal,j,j) Entonces
OK <- Verdadero
j<-16 // Si encuentra el número, sale del bucle
SiNo
// Si cad tiene un dígito que no forma parte de la base hexadecimal
// sale del bucle y devuelve falso
Si (j==16) Entonces
OK <- Falso
i<-Longitud(cad)
FinSi
FinSi
FinPara
FinPara
FinFuncion
Funcion nOctal <- deBinarioAOctal(cad)
Dimension tablaBinarios[8]
Definir cad2, nOctal, nBin, faltan0, tablaBinarios Como Cadena
Definir i, j Como Entero
tablaBinarios[1] <- "000"
tablaBinarios[2] <- "001"
tablaBinarios[3] <- "010"
tablaBinarios[4] <- "011"
tablaBinarios[5] <- "100"
tablaBinarios[6] <- "101"
tablaBinarios[7] <- "110"
tablaBinarios[8] <- "111"
i<-Longitud(cad)
faltan0 <- ""
// Si al hacer grupos de 3 el número binario,
// se queda el primer grupo con menos de 3 números,
// añadimos 1 o 2 ceros, para completarlo
Si !(i%3==0) Entonces
Para j<-1 Hasta (3-(i%3)) Con Paso 1
faltan0 <- faltan0 + '0'
FinPara
FinSi
cad <- faltan0+cad
nOctal <- ""
i<-Longitud(cad)
Repetir
// Vamos mirando en número binario de derecha a izquierda, en grupos de 3,
// buscando el número correspondiente en octal a cada grupo, y guardándolo
// en cad2. Se guarda al revés, hay que cambiar el orden después
nBin <- Subcadena(cad,i-2,i)
Para j<-1 Hasta 8 Con Paso 1 Hacer
Si nBin==tablaBinarios[j] Entonces
cad2 <- cad2 + ConvertirATexto(j-1)
FinSi
FinPara
i<-i-3
Hasta Que (i<=0)
// Cambiamos el orden para obtener el número correcto
Para i<-Longitud(cad2) Hasta 1 Con Paso -1
nOctal <- nOctal + Subcadena(cad2,i,i)
FinPara
// Quitamos los ceros a la izquierda del número octal
nOctal <- quitarCeros(nOctal)
FinFuncion
Funcion nBin <- deOctalABinario(cad)
Dimension tablaBinarios[8]
Definir nBin, nOctal, faltan0, tablaBinarios Como Cadena
Definir i, j Como Entero
Definir C Como Caracter
tablaBinarios[1] <- "000"
tablaBinarios[2] <- "001"
tablaBinarios[3] <- "010"
tablaBinarios[4] <- "011"
tablaBinarios[5] <- "100"
tablaBinarios[6] <- "101"
tablaBinarios[7] <- "110"
tablaBinarios[8] <- "111"
cad2 <- ""
Para i<-1 Hasta Longitud(cad) Con Paso 1 Hacer
C<-Subcadena(cad,i,i)
nBin <- nBin + tablaBinarios[ConvertirANumero(C)+1]
FinPara
FinFuncion
Funcion nBin <- deHexadecimalABinario(cad)
Dimension tablaBinarios[16]
Definir nBin, nHexa, faltan0, tablaBinarios, C Como Cadena
Definir i, j Como Entero
tablaBinarios[1] <- "0000"
tablaBinarios[2] <- "0001"
tablaBinarios[3] <- "0010"
tablaBinarios[4] <- "0011"
tablaBinarios[5] <- "0100"
tablaBinarios[6] <- "0101"
tablaBinarios[7] <- "0110"
tablaBinarios[8] <- "0111"
tablaBinarios[9] <- "1000"
tablaBinarios[10] <- "1001"
tablaBinarios[11] <- "1010"
tablaBinarios[12] <- "1011"
tablaBinarios[13] <- "1100"
tablaBinarios[14] <- "1101"
tablaBinarios[15] <- "1110"
tablaBinarios[16] <- "1111"
cad2 <- ""
Para i<-1 Hasta Longitud(cad) Con Paso 1 Hacer
j<-ConvertirANumero(numHexa(Subcadena(cad,i,i)))
nBin <- nBin + tablaBinarios[j+1]
FinPara
FinFuncion
Funcion nHex <- deOctalAHexadecimal(cad)
Dimension tablaBinarios[16]
Definir cad2, nHex, nBin, nOctal, faltan0, tablaBinarios Como Cadena
Definir i, j Como Entero
Definir C Como Caracter
tablaBinarios[1] <- "0000"
tablaBinarios[2] <- "0001"
tablaBinarios[3] <- "0010"
tablaBinarios[4] <- "0011"
tablaBinarios[5] <- "0100"
tablaBinarios[6] <- "0101"
tablaBinarios[7] <- "0110"
tablaBinarios[8] <- "0111"
tablaBinarios[9] <- "1000"
tablaBinarios[10] <- "1001"
tablaBinarios[11] <- "1010"
tablaBinarios[12] <- "1011"
tablaBinarios[13] <- "1100"
tablaBinarios[14] <- "1101"
tablaBinarios[15] <- "1110"
tablaBinarios[16] <- "1111"
cad <- deOctalABinario(cad)
i<-Longitud(cad)
faltan0 <- ""
// Si al hacer grupos de 4 el número binario,
// se queda el primer grupo con menos de 4 números,
// añadimos de 1 a 3 ceros, para completarlo
Si !(i%4==0) Entonces
Para j<-1 Hasta (4-(i%4)) Con Paso 1
faltan0 <- faltan0 + '0'
FinPara
FinSi
cad <- faltan0+cad
nHex <- ""
i<-Longitud(cad)
Repetir
// Vamos mirando en número binario de derecha a izquierda, en grupos de 4,
// buscando el número correspondiente en hexadecimal a cada grupo, y guardándolo
// en cad2. Se guarda al revés, hay que cambiar el orden después
nBin <- Subcadena(cad,i-3,i)
Para j<-1 Hasta 16 Con Paso 1 Hacer
Si nBin==tablaBinarios[j] Entonces
Si (j-1) >= 10 Entonces
cad2 <- cad2 + letraHexa(ConvertirATexto(j-1))
SiNo
cad2 <- cad2 + ConvertirATexto(j-1)
FinSi
j<-16 // Después de encontrar el número sale del bucle
FinSi
FinPara
i<-i-4
Hasta Que (i<=0)
// Cambiamos el orden para obtener el número correcto
Para i<-Longitud(cad2) Hasta 1 Con Paso -1
nHex <- nHex + Subcadena(cad2,i,i)
FinPara
// Quitamos los ceros a la izquierda del número octal
nHex <- quitarCeros(nHex)
FinFuncion
Funcion nOctal <- deHexadecimalAOctal(cad)
Dimension tablaBinarios[16]
Definir cad2, nHex, nBin, nOctal, faltan0, tablaBinarios Como Cadena
Definir i, j Como Entero
Definir C Como Caracter
tablaBinarios[1] <- "0000"
tablaBinarios[2] <- "0001"
tablaBinarios[3] <- "0010"
tablaBinarios[4] <- "0011"
tablaBinarios[5] <- "0100"
tablaBinarios[6] <- "0101"
tablaBinarios[7] <- "0110"
tablaBinarios[8] <- "0111"
tablaBinarios[9] <- "1000"
tablaBinarios[10] <- "1001"
tablaBinarios[11] <- "1010"
tablaBinarios[12] <- "1011"
tablaBinarios[13] <- "1100"
tablaBinarios[14] <- "1101"
tablaBinarios[15] <- "1110"
tablaBinarios[16] <- "1111"
cad <- deHexadecimalABinario(cad)
nOctal <- deBinarioAOctal(cad)
// Quitamos los ceros a la izquierda del número octal
nOctal <- quitarCeros(nOctal)
FinFuncion
Funcion nHexa <- deBinarioAHexadecimal(cad)
Dimension tablaBinarios[16]
Definir cad2, nHexa, nBin, faltan0, tablaBinarios Como Cadena
Definir i, j Como Entero
tablaBinarios[1] <- "0000"
tablaBinarios[2] <- "0001"
tablaBinarios[3] <- "0010"
tablaBinarios[4] <- "0011"
tablaBinarios[5] <- "0100"
tablaBinarios[6] <- "0101"
tablaBinarios[7] <- "0110"
tablaBinarios[8] <- "0111"
tablaBinarios[9] <- "1000"
tablaBinarios[10] <- "1001"
tablaBinarios[11] <- "1010"
tablaBinarios[12] <- "1011"
tablaBinarios[13] <- "1100"
tablaBinarios[14] <- "1101"
tablaBinarios[15] <- "1110"
tablaBinarios[16] <- "1111"
i<-Longitud(cad)
faltan0 <- ""
// Si al hacer grupos de 4 el número binario,
// se queda el primer grupo con menos de 3 números,
// añadimos 1 a 3 ceros, para completarlo
Si !(i%4==0) Entonces
Para j<-1 Hasta (4-(i%4)) Con Paso 1
faltan0 <- faltan0 + '0'
FinPara
FinSi
cad <- faltan0+cad
nHexa <- ""
i<-Longitud(cad)
Repetir
// Vamos mirando en número binario de derecha a izquierda, en grupos de 4,
// buscando el número correspondiente en hexadecimal a cada grupo, y guardándolo
// en cad2. Se guarda al revés, hay que cambiar el orden después
nBin <- Subcadena(cad,i-3,i)
Para j<-1 Hasta 16 Con Paso 1 Hacer
Si nBin==tablaBinarios[j] Entonces
Si (j-1) >= 10 Entonces
cad2 <- cad2 + letraHexa(ConvertirATexto(j-1))
SiNo
cad2 <- cad2 + ConvertirATexto(j-1)
FinSi
j<-16 // Después de encontrar el número sale del bucle
FinSi
FinPara
i<-i-4
Hasta Que (i<=0)
// Cambiamos el orden para obtener el número correcto
Para i<-Longitud(cad2) Hasta 1 Con Paso -1
nHexa <- nHexa + Subcadena(cad2,i,i)
FinPara
// Quitamos los ceros a la izquierda del número octal
nHexa <- quitarCeros(nHexa)
FinFuncion
Funcion n <- letraHexa(cad)
Definir n Como Caracter
Segun ConvertirANumero(cad) Hacer
10:
n<-'A'
11:
n<-'B'
12:
n<-'C'
13:
n<-'D'
14:
n<-'E'
15:
n<-'F'
FinSegun
FinFuncion
Funcion n <- numHexa(C)
// Recibe el dígito hexadecimal y devuelve
// el índice-1 de la tablaBinarios
Definir n, digitos Como Cadena
Si Mayusculas(C)=='A' Entonces
n <- '10'
SiNo
Si Mayusculas(C)=='B' Entonces
n <- '11'
SiNo
Si Mayusculas(C)=='C' Entonces
n <- '12'
SiNo
Si Mayusculas(C)=='D' Entonces
n <- '13'
SiNo
Si Mayusculas(C)=='E' Entonces
n <- '14'
SiNo
Si Mayusculas(C)=='F' Entonces
n <- '15'
SiNo
digitos <- "0123456789"
Para i<-1 Hasta 10 Con Paso 1 Hacer
Si C==Subcadena(digitos,i,i) Entonces
n <- C
i<-10
FinSi
FinPara
FinSi
FinSi
FinSi
FinSi
FinSi
FinSi
FinFuncion
Funcion cad <- quitarCeros(cad)
// Quita ceros a la izquierda de números en octal, hexadecimal o decimal
Definir i Como Entero
Definir n Como Cadena
Para i<-1 Hasta Longitud(cad) Con Paso 1 Hacer
Si Subcadena(cad,1,1)=='0' Y Longitud(cad)>1 Entonces
cad <- Subcadena(cad,2,Longitud(cad))
FinSi
FinPara
FinFuncion
ResponderAlgoritmo menuCambiarBase
Definir opcMenu Como Entero
Definir salir Como Logico
salir <- Falso
Repetir
Escribir " MENU"
Escribir "------------------------------------------"
Escribir "(1) De binario a octal y vicecersa"
Escribir "(2) De octal a hexadecimal y viceversa"
Escribir "(3) De binario a hexadecimal y viceversa"
Escribir "(4) Salir"
Escribir "Elija una opción...." Sin Saltar
Leer opcMenu
Borrar Pantalla
Segun opcMenu Hacer
1:
opcion1
2:
opcion2
3:
opcion3
4:
salir <- Verdadero
De Otro Modo:
Escribir "Opción incorrecta. Inténtelo de nuevo"
FinSegun
Hasta Que salir
FinAlgoritmo
Funcion opcion1
Definir opc Como Entero
Definir volver Como Logico
Definir num Como Cadena
volver <- Falso
Mientras !volver
Escribir " CONVERTIR"
Escribir "------------------------------"
Escribir "(1) De binario a octal"
Escribir "(2) De octal a binario"
Escribir "(3) Volver al menú anterior"
Escribir "Eligir opción (1 al 3)...." Sin Saltar
Leer opc
Borrar Pantalla
Segun opc Hacer
1:
Escribir "NÚMERO EN BINARIO: " Sin Saltar
Leer num
Si esBinario(num) Entonces
Escribir "Es ", deBinarioAOctal(num), " en octal"
SiNo
Escribir "No es un número binario"
FinSi
teclayBorrar
2:
Escribir "NÚMERO EN OCTAL: " Sin Saltar
Leer num
Si esOctal(num) Entonces
num <- quitarCeros(num)
Escribir "Es ", deOctalABinario(num), " en binario"
SiNo
Escribir "No es un número octal"
FinSi
teclayBorrar
3:
Borrar Pantalla
volver<-Verdadero
De Otro Modo:
Escribir "Opción incorrecta. Inténtelo de nuevo"
teclayBorrar
FinSegun
FinMientras
FinFuncion
Funcion opcion2
Definir opc Como Entero
Definir volver Como Logico
Definir num Como Cadena
volver <- Falso
Mientras !volver
Escribir " CONVERTIR"
Escribir "------------------------------"
Escribir "(1) De octal a hexadecimal"
Escribir "(2) De hexadecimal a octal"
Escribir "(3) Volver al menú anterior"
Escribir "Eligir opción (1 al 3)...." Sin Saltar
Leer opc
Borrar Pantalla
Segun opc Hacer
1:
Escribir "NÚMERO EN OCTAL: " Sin Saltar
Leer num
Si esOctal(num) Entonces
num <- quitarCeros(num)
Escribir "Es ", deOctalAHexadecimal(num), " en hexadecimal"
SiNo
Escribir "No es un número octal"
FinSi
teclayBorrar
2:
Escribir "NÚMERO EN HEXADECIMAL: " Sin Saltar
Leer num
Si esHexadecimal(num) Entonces
num <- quitarCeros(num)
Escribir "Es ", deHexadecimalAOctal(num) " en octal"
SiNo
Escribir "No es un número hexadecimal"
FinSi
teclayBorrar
3:
Borrar Pantalla
volver<-Verdadero
De Otro Modo:
Escribir "Opción incorrecta. Inténtelo de nuevo"
teclayBorrar
FinSegun
FinMientras
FinFuncion
Funcion opcion3
Definir opc Como Entero
Definir volver Como Logico
volver <- Falso
Mientras !volver
Escribir " CONVERTIR"
Escribir "------------------------------"
Escribir "(1) De binario a hexadecimal"
Escribir "(2) De hexadecimal a binario"
Escribir "(3) Volver al menú anterior"
Escribir "Eligir opción (1 al 3)...." Sin Saltar
Leer opc
Borrar Pantalla
Segun opc Hacer
1:
Escribir "NÚMERO EN BINARIO: " Sin Saltar
Leer num
Si esBinario(num) Entonces
Escribir "Es ", deBinarioAHexadecimal(num), " en hexadecimal"
SiNo
Escribir "No es un número binario"
FinSi
teclayBorrar
2:
Escribir "NÚMERO EN HEXADECIMAL: " Sin Saltar
Leer num
Si esHexadecimal(num) Entonces
num <- quitarCeros(num)
Escribir "Es ", deHexadecimalABinario(num) " en binario"
SiNo
Escribir "No es un número hexadecimal"
FinSi
teclayBorrar
3:
Borrar Pantalla
volver<-Verdadero
De Otro Modo:
Escribir "Opción incorrecta. Inténtelo de nuevo"
teclayBorrar
FinSegun
FinMientras
FinFuncion
Funcion teclayBorrar
Escribir "Pulse una tecla para continuar...."
Esperar Tecla
Borrar Pantalla
FinFuncion
Funcion OK <- esBinario(cad)
Definir OK Como Logico
Definir i Como Entero
OK <- Falso
// Comprobar que la cadena recibida está compuesta solo de ceros y unos
Para i<-1 Hasta Longitud(cad) Con Paso 1 Hacer
Si Subcadena(cad,i,i)=='1' O Subcadena(cad,i,i)=='0' Entonces
OK <- Verdadero
SiNo
// Si encuentra un caracter que no es un 1 o un 0 sale del bucle
OK <- Falso
i <- Longitud(cad)
FinSi
FinPara
FinFuncion
Funcion OK <- esOctal(cad)
Definir OK Como Logico
Definir i Como Entero
Definir C Como Caracter
valoresOctal <- "01234567"
OK <- Falso
// Comprobar que la cadena recibida está compuesta solo por dígitos del 0 al 7
Para i<-1 Hasta Longitud(cad) Con Paso 1 Hacer
C <- Subcadena(cad,i,i)
Para j<-1 Hasta 8 Con Paso 1 Hacer
Si C==Subcadena(valoresOctal,j,j) Entonces
OK <- Verdadero
j<-8 // Si encuentra el número, sale del bucle
SiNo
// Si cad tiene un dígito que no forma parte de la base octal
// sale del bucle y devuelve falso
Si (j==8) Entonces
OK <- Falso
i<-Longitud(cad)
FinSi
FinSi
FinPara
FinPara
FinFuncion
Funcion OK <- esHexadecimal(cad)
Definir OK Como Logico
Definir i Como Entero
Definir C Como Caracter
valoresOctal <- "0123456789ABCDEF"
OK <- Falso
// Comprobar que la cadena recibida está compuesta solo por dígitos del 0 al F
Para i<-1 Hasta Longitud(cad) Con Paso 1 Hacer
C <- Subcadena(cad,i,i)
Para j<-1 Hasta 16 Con Paso 1 Hacer
Si Mayusculas(C)==Subcadena(valoresOctal,j,j) Entonces
OK <- Verdadero
j<-16 // Si encuentra el número, sale del bucle
SiNo
// Si cad tiene un dígito que no forma parte de la base hexadecimal
// sale del bucle y devuelve falso
Si (j==16) Entonces
OK <- Falso
i<-Longitud(cad)
FinSi
FinSi
FinPara
FinPara
FinFuncion
Funcion nOctal <- deBinarioAOctal(cad)
Dimension tablaBinarios[8]
Definir cad2, nOctal, nBin, faltan0, tablaBinarios Como Cadena
Definir i, j Como Entero
tablaBinarios[1] <- "000"
tablaBinarios[2] <- "001"
tablaBinarios[3] <- "010"
tablaBinarios[4] <- "011"
tablaBinarios[5] <- "100"
tablaBinarios[6] <- "101"
tablaBinarios[7] <- "110"
tablaBinarios[8] <- "111"
i<-Longitud(cad)
faltan0 <- ""
// Si al hacer grupos de 3 el número binario,
// se queda el primer grupo con menos de 3 números,
// añadimos 1 o 2 ceros, para completarlo
Si !(i%3==0) Entonces
Para j<-1 Hasta (3-(i%3)) Con Paso 1
faltan0 <- faltan0 + '0'
FinPara
FinSi
cad <- faltan0+cad
nOctal <- ""
i<-Longitud(cad)
Repetir
// Vamos mirando en número binario de derecha a izquierda, en grupos de 3,
// buscando el número correspondiente en octal a cada grupo, y guardándolo
// en cad2. Se guarda al revés, hay que cambiar el orden después
nBin <- Subcadena(cad,i-2,i)
Para j<-1 Hasta 8 Con Paso 1 Hacer
Si nBin==tablaBinarios[j] Entonces
cad2 <- cad2 + ConvertirATexto(j-1)
FinSi
FinPara
i<-i-3
Hasta Que (i<=0)
// Cambiamos el orden para obtener el número correcto
Para i<-Longitud(cad2) Hasta 1 Con Paso -1
nOctal <- nOctal + Subcadena(cad2,i,i)
FinPara
// Quitamos los ceros a la izquierda del número octal
nOctal <- quitarCeros(nOctal)
FinFuncion
Funcion nBin <- deOctalABinario(cad)
Dimension tablaBinarios[8]
Definir nBin, nOctal, faltan0, tablaBinarios Como Cadena
Definir i, j Como Entero
Definir C Como Caracter
tablaBinarios[1] <- "000"
tablaBinarios[2] <- "001"
tablaBinarios[3] <- "010"
tablaBinarios[4] <- "011"
tablaBinarios[5] <- "100"
tablaBinarios[6] <- "101"
tablaBinarios[7] <- "110"
tablaBinarios[8] <- "111"
cad2 <- ""
Para i<-1 Hasta Longitud(cad) Con Paso 1 Hacer
C<-Subcadena(cad,i,i)
nBin <- nBin + tablaBinarios[ConvertirANumero(C)+1]
FinPara
FinFuncion
Funcion nBin <- deHexadecimalABinario(cad)
Dimension tablaBinarios[16]
Definir nBin, nHexa, faltan0, tablaBinarios, C Como Cadena
Definir i, j Como Entero
tablaBinarios[1] <- "0000"
tablaBinarios[2] <- "0001"
tablaBinarios[3] <- "0010"
tablaBinarios[4] <- "0011"
tablaBinarios[5] <- "0100"
tablaBinarios[6] <- "0101"
tablaBinarios[7] <- "0110"
tablaBinarios[8] <- "0111"
tablaBinarios[9] <- "1000"
tablaBinarios[10] <- "1001"
tablaBinarios[11] <- "1010"
tablaBinarios[12] <- "1011"
tablaBinarios[13] <- "1100"
tablaBinarios[14] <- "1101"
tablaBinarios[15] <- "1110"
tablaBinarios[16] <- "1111"
cad2 <- ""
Para i<-1 Hasta Longitud(cad) Con Paso 1 Hacer
j<-ConvertirANumero(numHexa(Subcadena(cad,i,i)))
nBin <- nBin + tablaBinarios[j+1]
FinPara
FinFuncion
Funcion nHex <- deOctalAHexadecimal(cad)
Dimension tablaBinarios[16]
Definir cad2, nHex, nBin, nOctal, faltan0, tablaBinarios Como Cadena
Definir i, j Como Entero
Definir C Como Caracter
tablaBinarios[1] <- "0000"
tablaBinarios[2] <- "0001"
tablaBinarios[3] <- "0010"
tablaBinarios[4] <- "0011"
tablaBinarios[5] <- "0100"
tablaBinarios[6] <- "0101"
tablaBinarios[7] <- "0110"
tablaBinarios[8] <- "0111"
tablaBinarios[9] <- "1000"
tablaBinarios[10] <- "1001"
tablaBinarios[11] <- "1010"
tablaBinarios[12] <- "1011"
tablaBinarios[13] <- "1100"
tablaBinarios[14] <- "1101"
tablaBinarios[15] <- "1110"
tablaBinarios[16] <- "1111"
cad <- deOctalABinario(cad)
i<-Longitud(cad)
faltan0 <- ""
// Si al hacer grupos de 4 el número binario,
// se queda el primer grupo con menos de 4 números,
// añadimos de 1 a 3 ceros, para completarlo
Si !(i%4==0) Entonces
Para j<-1 Hasta (4-(i%4)) Con Paso 1
faltan0 <- faltan0 + '0'
FinPara
FinSi
cad <- faltan0+cad
nHex <- ""
i<-Longitud(cad)
Repetir
// Vamos mirando en número binario de derecha a izquierda, en grupos de 4,
// buscando el número correspondiente en hexadecimal a cada grupo, y guardándolo
// en cad2. Se guarda al revés, hay que cambiar el orden después
nBin <- Subcadena(cad,i-3,i)
Para j<-1 Hasta 16 Con Paso 1 Hacer
Si nBin==tablaBinarios[j] Entonces
Si (j-1) >= 10 Entonces
cad2 <- cad2 + letraHexa(ConvertirATexto(j-1))
SiNo
cad2 <- cad2 + ConvertirATexto(j-1)
FinSi
j<-16 // Después de encontrar el número sale del bucle
FinSi
FinPara
i<-i-4
Hasta Que (i<=0)
// Cambiamos el orden para obtener el número correcto
Para i<-Longitud(cad2) Hasta 1 Con Paso -1
nHex <- nHex + Subcadena(cad2,i,i)
FinPara
// Quitamos los ceros a la izquierda del número octal
nHex <- quitarCeros(nHex)
FinFuncion
Funcion nOctal <- deHexadecimalAOctal(cad)
Dimension tablaBinarios[16]
Definir cad2, nHex, nBin, nOctal, faltan0, tablaBinarios Como Cadena
Definir i, j Como Entero
Definir C Como Caracter
tablaBinarios[1] <- "0000"
tablaBinarios[2] <- "0001"
tablaBinarios[3] <- "0010"
tablaBinarios[4] <- "0011"
tablaBinarios[5] <- "0100"
tablaBinarios[6] <- "0101"
tablaBinarios[7] <- "0110"
tablaBinarios[8] <- "0111"
tablaBinarios[9] <- "1000"
tablaBinarios[10] <- "1001"
tablaBinarios[11] <- "1010"
tablaBinarios[12] <- "1011"
tablaBinarios[13] <- "1100"
tablaBinarios[14] <- "1101"
tablaBinarios[15] <- "1110"
tablaBinarios[16] <- "1111"
cad <- deHexadecimalABinario(cad)
nOctal <- deBinarioAOctal(cad)
// Quitamos los ceros a la izquierda del número octal
nOctal <- quitarCeros(nOctal)
FinFuncion
Funcion nHexa <- deBinarioAHexadecimal(cad)
Dimension tablaBinarios[16]
Definir cad2, nHexa, nBin, faltan0, tablaBinarios Como Cadena
Definir i, j Como Entero
tablaBinarios[1] <- "0000"
tablaBinarios[2] <- "0001"
tablaBinarios[3] <- "0010"
tablaBinarios[4] <- "0011"
tablaBinarios[5] <- "0100"
tablaBinarios[6] <- "0101"
tablaBinarios[7] <- "0110"
tablaBinarios[8] <- "0111"
tablaBinarios[9] <- "1000"
tablaBinarios[10] <- "1001"
tablaBinarios[11] <- "1010"
tablaBinarios[12] <- "1011"
tablaBinarios[13] <- "1100"
tablaBinarios[14] <- "1101"
tablaBinarios[15] <- "1110"
tablaBinarios[16] <- "1111"
i<-Longitud(cad)
faltan0 <- ""
// Si al hacer grupos de 4 el número binario,
// se queda el primer grupo con menos de 3 números,
// añadimos 1 a 3 ceros, para completarlo
Si !(i%4==0) Entonces
Para j<-1 Hasta (4-(i%4)) Con Paso 1
faltan0 <- faltan0 + '0'
FinPara
FinSi
cad <- faltan0+cad
nHexa <- ""
i<-Longitud(cad)
Repetir
// Vamos mirando en número binario de derecha a izquierda, en grupos de 4,
// buscando el número correspondiente en hexadecimal a cada grupo, y guardándolo
// en cad2. Se guarda al revés, hay que cambiar el orden después
nBin <- Subcadena(cad,i-3,i)
Para j<-1 Hasta 16 Con Paso 1 Hacer
Si nBin==tablaBinarios[j] Entonces
Si (j-1) >= 10 Entonces
cad2 <- cad2 + letraHexa(ConvertirATexto(j-1))
SiNo
cad2 <- cad2 + ConvertirATexto(j-1)
FinSi
j<-16 // Después de encontrar el número sale del bucle
FinSi
FinPara
i<-i-4
Hasta Que (i<=0)
// Cambiamos el orden para obtener el número correcto
Para i<-Longitud(cad2) Hasta 1 Con Paso -1
nHexa <- nHexa + Subcadena(cad2,i,i)
FinPara
// Quitamos los ceros a la izquierda del número octal
nHexa <- quitarCeros(nHexa)
FinFuncion
Funcion n <- letraHexa(cad)
Definir n Como Caracter
Segun ConvertirANumero(cad) Hacer
10:
n<-'A'
11:
n<-'B'
12:
n<-'C'
13:
n<-'D'
14:
n<-'E'
15:
n<-'F'
FinSegun
FinFuncion
Funcion n <- numHexa(C)
// Recibe el dígito hexadecimal y devuelve
// el índice-1 de la tablaBinarios
Definir n, digitos Como Cadena
Si Mayusculas(C)=='A' Entonces
n <- '10'
SiNo
Si Mayusculas(C)=='B' Entonces
n <- '11'
SiNo
Si Mayusculas(C)=='C' Entonces
n <- '12'
SiNo
Si Mayusculas(C)=='D' Entonces
n <- '13'
SiNo
Si Mayusculas(C)=='E' Entonces
n <- '14'
SiNo
Si Mayusculas(C)=='F' Entonces
n <- '15'
SiNo
digitos <- "0123456789"
Para i<-1 Hasta 10 Con Paso 1 Hacer
Si C==Subcadena(digitos,i,i) Entonces
n <- C
i<-10
FinSi
FinPara
FinSi
FinSi
FinSi
FinSi
FinSi
FinSi
FinFuncion
Funcion cad <- quitarCeros(cad)
// Quita ceros a la izquierda de números en octal, hexadecimal o decimal
Definir i Como Entero
Definir n Como Cadena
Para i<-1 Hasta Longitud(cad) Con Paso 1 Hacer
Si Subcadena(cad,1,1)=='0' Y Longitud(cad)>1 Entonces
cad <- Subcadena(cad,2,Longitud(cad))
FinSi
FinPara
FinFuncion
EJECUCIONES:
.png)
Comentarios
Publicar un comentario