ISC :SOFIA

lunes, 3 de abril de 2017

ANALIZADOR LEXICO CODIGO DEV C++

#include <stdio.h>
#include <conio.h>
#include <string.h>

int contar_vocales(char *);

int main(){

char cad[300];
int longi;
float porc;

printf("Ingrese el texto a contar vocales : ");
gets(cad);
longi = strlen(cad);
printf("La cantidad de Vocales: %d",contar_vocales(cad));
printf("\nCantidad de caracteres: %d",longi);
getch();

}

//-- Funcion:

int contar_vocales(char *cad){

int cont=0;
char *aux=cad;

while(*aux){
if(*aux=='a'||*aux=='e'||*aux=='i'||*aux=='o'||*aux=='u')
cont++;
aux++;
}//función

return cont;

}//contar_vocales

martes, 28 de marzo de 2017

Eliminación de la Recursividad Izquierda

1. Se agrupan todas las producciones de A en la forma:

A→ A α 1|A α 2| … |A α m| β 1 |β 2| … | β n , donde ninguna βi comienza con una A.

2. Se sustituyen las producciones de A por:

A→ β 1A’| β 2A’|…|β nA’ • A’→ α 1A’|α 2A’|…|α mA’| ε

Una gramática es recursiva por la izquierda si tiene un no terminal A tal que existe una derivación A Aα para alguna cadena α. Los métodos de análisis sintáctico descendente no pueden manejar gramáticas recursivas por la izquierda, así que se necesita una transformación que elimine la recursión por la izquierda.

Ejemplo: Eliminar la recursividad a izquierdas de: E → E+T E → T T → F F → (E) F → id T → T*F

•Se identifica si cada una de las producciones que tienen la forma:

A→ A α| β

•La producción E → E+T ,

tiene recursividad izquierda, por lo que: E → E+T | T A→ A α| β Se igualan los símbolos según la formula:

A = E

α = + T

β = T

Se utilizan las reglas de remplazo

A→ β1A’| β2A’|…|βnA’

A’→ α1A’|α2A’|…|αmA’|

ε E → TE’

E’ → +TE’|ε 6

A las producciónes T → T*F | F, también se le aplica el mismo proceso :

A = T

α = *F

β = F

• Se utilizan las reglas de remplazo

A→ β1A’| β2A’|…|βnA’

A’→ α1A’|α2A’|…|αmA’|

ε T→ FT’

T’→ *FT’ | ε

Se hace necesario eliminar las producciones del tipo A→ λ para dejar una gramática bien formada.

E → TE’

E’ → +TE’

E→ T

E’→ +T

T→ FT’

T→ F

T’→ *FT’

T’→ *F

F→ (E)

F→ id

Se hace necesario también eliminar las reglas de redenominación.

E → TE’

E’ → +TE’

E→ (E)

E→ id

E’→ +T

T→ FT’

T→ (E)

T→ id

T’→ *FT’

T’→ *F

F→ (T)

F→ id

Finalmente la gramática no recursiva por izquierda es:

E → TE’

E’ → +TE’

E→ (E)

E→ id

E→ +T

T→ FT’

T→ (E)

T→ id

T’→ *FT’

T’→ *F

F→ (T)

F→ id

ANALIZADOR SINTÁCTICO

Análisis Sintáctico

· La principal tarea del analizador sintáctico no es comprobar que la sintaxis del programa fuente sea correcta.

· El analizador sintáctico (A.S.) comprueba que el orden en que el analizador léxico le va entregando los tokens es válido. Si esto es así significará que la sucesión de símbolos que representan dichos tokens puede ser generada por la gramática correspondiente al lenguaje del código fuente.

· La forma más habitual de representar la sintaxis de un programa es el árbol de análisis sintáctico, y lo que hacen los analizadores sintácticos es construir una derivación por la izquierda o por la derecha del programa fuente, que en realidad son dos recorridos determinados del árbol de análisis sintáctico

Sus funciones son :

· Aceptar lo que es válido sintácticamente y rechazar lo que no lo es.

· Hacer explícito el orden jerárquico que tienen los operadores en el lenguaje de que se trate. Por ejemplo, la cadena A/B*C es interpretada como (A/B)*C en FORTRAN y comoA/(B*C) en APL.

· Guiar el proceso de traducción (traducción dirigida por la sintaxis).

Clasificación :

La tarea esencial de un analizador es determinar si una determinada entrada puede ser derivada desde el símbolo inicial, usando las reglas de una gramática formal, y como hacer esto, existen esencialmente dos formas:

· ANÁLISIS SINTÁCTICO DESCENDENTE (Top-Down-Parser):

Un analizador puede empezar con el símbolo inicial e intentar transformarlo en la entrada, intuitivamente esto sería ir dividiendo la entrada progresivamente en partes cada vez más pequeñas, de esta forma funcionan los analizadores LL, un ejemplo es el javaCC.

· ANÁLISIS SINTÁCTICO ASCENDENTE (Bottom-Up-Parser):

Un analizador puede empezar con la entrada e intentar llegar hasta el símbolo inicial, intuitivamente el analizador intenta encontrar los símbolos más pequeños y progresivamente construir la jerarquía de símbolos hasta el inicial, los analizadores LR funcionan así

ANÁLISIS SINTÁCTICO POR PRECEDENCIA DE OPERADORES

Para una pequeña clase de gramáticas se puede construir con facilidad a mano eficientes analizadores sintácticos ascendentes.Estas gramáticas, por precedencia de operadores, tienen la propiedad de que ningún lado derecho de la producción es є ni tiene 2 terminales adyacentes.
Una gramática con esta última propiedad de denomina gramática de operadores.

ANALIZADORES SINTÁCTICOS IZQUIERDA-DERECHA

Es una técnica eficiente de análisis sintáctico ascendente que se puede utilizar para analizar una amplia clase de gramáticas independientes de contexto, denominada Análisis sintáctico LR(k)

L es por el examen de la entrada de izquierda a derecha (left to right)
R por construir una derivación por la derecha (right most derivation) en orden inverso.
K por el número de símbolos de entrada de examen por anticipado utilizados para tomar decisiones del análisis sintáctico.
Cuando se omite, se asume que k es 1.
Este análisis es atractivo por varias razones:

• Reconocen prácticamente todas las construcciones de los lenguajes de programación para los que se pueden escribir gramáticas independientes del contexto.
• Puede detectar un error sintáctico tan pronto como sea posible hacerlo en un examen de izquierda a derecha de la entrada.

APLICABILIDAD

Un analizador sintáctico es un Autómata de pila que reconoce la estructura de una cadena de componentes léxicos.

CÓMO FUNCIONA (TEORÍA EN LA QUE SE BASA)

El analizador sintáctico, que se utilizara en esta práctica, será de tipo LL1 o SLR. Se pueden aplicar también técnicas mixtas, analizando, por ejemplo, las sentencias aritméticas con un analizador de lenguajes de precedencia y el resto del programa con LL1 o SLR. Si se utilizan herramientas de generación automática (compiladores de compiladores como yacc y bison) el lenguaje será del tipo LARL.

LL1:

Definición:

Se agrupan todas las clausuras con idéntica parte izquierda. Es decir todas las clausuras del tipo:

A -> B C D

A -> E F G

......

A ->X Y Z

Si no existen dos clausuras con idéntica parte izquierda que pueden empezar con un mismo símbolo terminal, y no existe recursividad a la izquierda, el lenguaje es LL1.

Nota:

1. No es necesario que la clausura empiece con símbolos terminales diferentes. Lo único que es necesario comprobar es si puede o no empezar con un símbolo terminal.

2. Para cualquier lenguaje independiente del contexto se puede definir la función FIRST(a), definida para todas las formas sentenciales, cuyo valor es un conjunto de los símbolos terminales con los que puede empezar a. Si al en el conjunto se incluye también la sentencia vacía l. Si l está en FIRST(a), entonces la clausura A->a puede también empezar con todos los símbolos terminales que pueden seguir a A, denominado FOLLOW(A). FOLLOW puede incluir también el símbolo de End-Of-File $. El cálculo de la función FOLLOW(A) es también esencial para el analizador SLR.

3.Para los lenguajes LL1 es posible construir un autómata finito a pila, con un solo estado que analice el lenguaje. Las decisiones del autómata se toman sólo a partir del último elemento de la pila y el símbolo de entrada.

En general, un analizador sintáctico es un autómata a pila.

El analizador sintáctico:

*Inicializa el compilador y AS en particular.

*Para cada símbolo de entrada llama al analizador morfológico y el AM proporciona el siguiente símbolo de entrada.

*Analizando el símbolo, la pila y el estado del autómata, el AS produce las estructuras necesarias para la siguiente etapa y en el caso de compilación dirigida por la sintaxis .

*invoca llamadas directas al analizador semántico y al generador de código.

*Escribe mensajes de errores y trata de limitar el efecto de estos errores.

Elección de algoritmos. Consideración de las diferencias, ventajas y desventajas.

Existen por lo menos cuatro maneras de hacer el analizador morfológico:

A. utilizando herramientas especializadas yacc/bison,

B. utilizando analizador del tipo SLR.

C. utilizando analizador LL1 con llamadas a funciones.

D. utilizando analizador LL1 con tabla.

lunes, 27 de febrero de 2017

Generación de código intermedio

Código intermedio

Esta fase del compilador no es en realidad una parte separada del compilador, la mayoría de los compiladores generan código como parte del proceso de análisis sintáctico, esto es debido a que requieren del árbol de sintaxis y si este no va a ser construido físicamente, entonces deberá acompañar al analizador sintáctico al barrer el árbol implícito.

El código intermedio no es el lenguaje de programación de ninguna máquina real, sino que corresponde a una máquina abstracta, que se debe de definir lo más general posible, de forma que sea posible traducir este código intermedio a cualquier máquina real.

Es la fase de compilador genera el código intermedio que es más parecido al código ensamblador, las operaciones por ejemplo nunca se hacen con dos o más operandos ,donde podremos reutilizar parte del compilador que genera código intermedio en otro compilador para una computadora con diferente procesador cambiando solamente el generador de código ensamblador al cual llamaremos BACK END.

El objetivo del código intermedio es reducir en el número de programas necesarios para construir traductores y permitir fácilmente la transportabilidad de una maquina a otra.

lunes, 20 de febrero de 2017

Analizador semántico

La fase de análisis semántico revisa el programa fuente para tratar de encontrar errores semánticos y reúne la información sobre los tipos para la fase posterior de generación de código. En ella se utiliza la estructura jerárquica determinada por la clase de análisis sintáctico para identificar los operadores y operandos de expresiones y proposiciones.

ACTIVIDAD: DOS CONCEPTOS MAS DE ANALIZADOR LÉXICO, EJEMPLO Y REPRESENTACIÓN DE SUS COMPONEN

La fase de análisis semántico de un procesador de lenguaje es aquélla que computa la información adicional necesaria para el procesamiento de un lenguaje, una vez que la estructura sintáctica de un programa haya sido obtenida. Es por tanto la fase posterior a la de análisis sintáctico y la última dentro del proceso de síntesis de un lenguaje de programación.

El objetivo principal del analizador semántico de un procesador de lenguaje es asegurarse de que el programa analizado satisfaga las reglas requeridas por la especificación del lenguaje, para garantizar su correcta ejecución. El tipo y dimensión de análisis semántico requerido varía enormemente de un lenguaje a otro.

La fase de análisis semántico revisa el programa fuente para tratar de encontrar errores semánticos y reúne la información sobre los tipos para la fase posterior de generación de código. En ella se utiliza la estructura jerárquica determinada por la fase de análisis sintáctico para identificar los operadores y operandos de expresiones y proposiciones.

Un componente importante del análisis semántico es la Verificación de Tipos. Aquí, el compilador verifica si cada operador tiene operandos permitidos por la especificación del lenguaje fuente.

Ejemplo:

Producciones

G={Vt, Vn, S, R}

Vt={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,2011,ENERO,FEBRERO,MARZO,ABRIL,MAYO,JUNIO,JULIO,AGOSTO,SEPTIEMBRE,OCTUBRE,NOVIEMBRE,DICIEMBRE }

Vn={Día, Mes, Año, M1, M2, M3,D1, D2, D3 }

REGLAS GRAMATICALES

S = Día/Mes/Año | Año/Mes/Día

Mes = M1|M2|M3

M2 = ABRIL|JUNIO|SEPTIEMBRE|NOVIEMBRE

M3 = FEBRERO

Día = D1|D2|D3

D1 = 2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|

D2 = 2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30

D3 = 1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28

Año = 2011

Reglas semánticas

S.Val = Día.Val /Mes.Val /Año.Val | Año.Val /Mes.Val /Día.Val

Mes.Val = M1.Val |M2.Val |M3.Val

M2.Val = ABRIL |JUNIO |SEPTIEMBRE |NOVIEMBRE

M3.Val = FEBRERO

Día.Val = D1.Val |D2.Val |D3.Val

D1.Val = 1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|

D2.Val = 1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30

D3.Val = 1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28

Año.Val = 2011

Análisis Sintáctico.

Determina si la secuencia de componentes léxicos sigue la estructura del lenguaje y obtiene la estructura jerárquica en forma de árbol, donde los modos son las construcciones de alto nivel de lenguaje.

Se determinan las relaciones estructurales entre los componentes léxicos, esto es semejante a realizar el análisis gramatical sobre una fase del lenguaje natural

La estructura sintáctica, se define entre las gramáticas independientes del con texto

Clasificación:
La tarea esencial de un analizador es determinar si una determinada entrada puede ser derivada desde el símbolo inicial, usando las reglas de una gramática formal, y como hacer esto, existen esencialmente dos formas:

· Analizador sintáctico descendente (Top-Down-Parser): un analizador puede empezar con el símbolo inicial e intentar transformarlo en la entrada, intuitivamente esto sería ir dividiendo la entrada progresivamente en partes cada vez más pequeñas, de esta forma funcionan los analizadores LL, un ejemplo es el javaCC.

· Analizador sintáctico ascendente (Bottom-Up-Parser): un analizador puede empezar con la entrada e intentar llegar hasta el símbolo inicial, intuitivamente el analizador intenta encontrar los símbolos más pequeños y progresivamente construir la jerarquía de símbolos hasta el inicial, los analizadores LR funcionan así

ACTIVIDAD: DOS CONCEPTOS MAS DE ANALIZADOR LÉXICO, EJEMPLO Y REPRESENTACIÓN DE SUS COMPONEN

Análisis Sintáctico: Se encarga de chequear la secuencia de tokens que se representa al texto de entrada, en la base a una gramática dada. En caso de que el programa sea válido, suministra el árbol sintáctico que lo reconoce en base a una representación computacional. Este árbol es el punto de partida de la fase posterior de la etapa de análisis: El analizador semántico.

Bibliografía: Compiladores, Traductores y Compiladores con Lex/Yacc , Sergio Gálvez Rojas y Miguel Ángel Mora Mata (2005).

Análisis Sintáctico: Comprueba que el orden en que el analizador léxico le va entregando los tokens es válido. Si esto es así significará que la sucesión de símbolos que representan dichos tokens puede ser generada por la gramática correspondiente al lenguaje del código fuente.

La forma más habitual de representar la sintaxis de un programa es el árbol de análisis sintáctico, y lo que hacen los analizadores sintácticos es construir una derivación por la izquierda o por la derecha del programa fuente, que en realidad son dos recorridos determinados del árbol de análisis sintáctico.

Funciones del analizador sintáctico:

*Comprobar si la cadena de componentes léxicos proporcionada por el analizador léxico puede ser generada por la gramática que define el lenguaje fuente.

*Construir el árbol de análisis sintáctico que define la estructura jerárquica de un programa y obtener la serie de derivaciones para generar la cadena de componentes léxicos. El árbol sintáctico se utilizara como representación intermedia en la generación de código. Informar de los errores sintácticos de forma precisa y significativa y debería estar dotado de un mecanismo de recuperación de errores para continuar con el análisis.

Ejemplo

Declarar Atributo de clase:
Modificador de Acceso +palabra reservada static+ tipo de dato + nombre del Atributo+;
Ejemplo:
public static int n1;

I---> MSTNE
M----> public, private, protected
S ----> static
T ----> double, int, string…
N -----> L|LN|LD
L -----> A..Z|a..z
D ---> 0..9
E ----> ;

ORDENADORES

ORDENADORES

Los ordenadores son una mezcla equilibrada de software y hardware

Clasificación del Software:

*Software de Sistema

*Software General: Ejemplos: Navegador, Office.

*Software de Aplicación:

*Software de compiladores: Borland.

Compilador: verificar la estructura de tu código.

Interprete: Es el que lo va a traducir a un lenguaje más sencillo.

Un carácter tiene: 8byte.

VAMOS A ENCRIPTAR EL SIGUIENTE TEXTO:

El vídeo proporciona una manera eficaz para ayudarle a demostrar el punto. Cuando haga clic en Vídeo en línea, puede pegar el código para insertar del vídeo que desea agregar. También puede escribir una palabra clave para buscar en línea el vídeo que mejor se adapte a su documento.

Para otorgar a su documento un aspecto profesional, Word proporciona encabezados, pies de página, páginas de portada y diseños de cuadro de texto que se complementan entre sí. Por ejemplo, puede agregar una portada coincidente, el encabezado y la barra lateral. Haga clic en Insertar y elija los elementos que desee de las distintas galerías.

Los temas y estilos también ayudan a mantener su documento coordinado. Cuando haga clic en Diseño y seleccione un tema nuevo, cambiarán las imágenes, gráficos y gráficos SmartArt para que coincidan con el nuevo tema. Al aplicar los estilos, los títulos cambian para coincidir con el nuevo tema.

Ahorre tiempo en Word con nuevos botones que se muestran donde se necesiten. Para cambiar la forma en que se ajusta una imagen en el documento, haga clic y aparecerá un botón de opciones de diseño junto a la imagen. Cuando trabaje en una tabla, haga clic donde desee agregar una fila o columna y, a continuación, haga clic en el signo más.

ENCRIPTAR EN BINARIO

01000101 01101100 00100000 01110110 11101101 01100100 01100101 01101111 00100000 01110000 01110010 01101111 01110000 01101111 01110010 01100011 01101001 01101111 01101110 01100001 00100000 01110101 01101110 01100001 00100000 01101101 01100001 01101110 01100101 01110010 01100001 00100000 01100101 01100110 01101001 01100011 01100001 01111010 00100000 01110000 01100001 01110010 01100001 00100000 01100001 01111001 01110101 01100100 01100001 01110010 01101100 01100101 00100000 01100001 00100000 01100100 01100101 01101101 01101111 01110011 01110100 01110010 01100001 01110010 00100000 01100101 01101100 00100000 01110000 01110101 01101110 01110100 01101111 00101110 00100000 01000011 01110101 01100001 01101110 01100100 01101111 00100000 01101000 01100001 01100111 01100001 00100000 01100011 01101100 01101001 01100011 00100000 01100101 01101110 00100000 01010110 11101101 01100100 01100101 01101111 00100000 01100101 01101110 00100000 01101100 11101101 01101110 01100101 01100001 00101100 00100000 01110000 01110101 01100101 01100100 01100101 00100000 01110000 01100101 01100111 01100001 01110010 00100000 01100101 01101100 00100000 01100011 11110011 01100100 01101001 01100111 01101111 00100000 01110000 01100001 01110010 01100001 00100000 01101001 01101110 01110011 01100101 01110010 01110100 01100001 01110010 00100000 01100100 01100101 01101100 00100000 01110110 11101101 01100100 01100101 01101111 00100000 01110001 01110101 01100101 00100000 01100100 01100101 01110011 01100101 01100001 00100000 01100001 01100111 01110010 01100101 01100111 01100001 01110010 00101110 00100000 01010100 01100001 01101101 01100010 01101001 11101001 01101110 00100000 01110000 01110101 01100101 01100100 01100101 00100000 01100101 01110011 01100011 01110010 01101001 01100010 01101001 01110010 00100000 01110101 01101110 01100001 00100000 01110000 01100001 01101100 01100001 01100010 01110010 01100001 00100000 01100011 01101100 01100001 01110110 01100101 00100000 01110000 01100001 01110010 01100001 00100000 01100010 01110101 01110011 01100011 01100001 01110010 00100000 01100101 01101110 00100000 01101100 11101101 01101110 01100101 01100001 00100000 01100101 01101100 00100000 01110110 11101101 01100100 01100101 01101111 00100000 01110001 01110101 01100101 00100000 01101101 01100101 01101010 01101111 01110010 00100000 01110011 01100101 00100000 01100001 01100100 01100001 01110000 01110100 01100101 00100000 01100001 00100000 01110011 01110101 00100000 01100100 01101111 01100011 01110101 01101101 01100101 01101110 01110100 01101111 00101110 00001010 01010000 01100001 01110010 01100001 00100000 01101111 01110100 01101111 01110010 01100111 01100001 01110010 00100000 01100001 00100000 01110011 01110101 00100000 01100100 01101111 01100011 01110101 01101101 01100101 01101110 01110100 01101111 00100000 01110101 01101110 00100000 01100001 01110011 01110000 01100101 01100011 01110100 01101111 00100000 01110000 01110010 01101111 01100110 01100101 01110011 01101001 01101111 01101110 01100001 01101100 00101100 00100000 01010111 01101111 01110010 01100100 00100000 01110000 01110010 01101111 01110000 01101111 01110010 01100011 01101001 01101111 01101110 01100001 00100000 01100101 01101110 01100011 01100001 01100010 01100101 01111010 01100001 01100100 01101111 01110011 00101100 00100000 01110000 01101001 01100101 01110011 00100000 01100100 01100101 00100000 01110000 11100001 01100111 01101001 01101110 01100001 00101100 00100000 01110000 11100001 01100111 01101001 01101110 01100001 01110011 00100000 01100100 01100101 00100000 01110000 01101111 01110010 01110100 01100001 01100100 01100001 00100000 01111001 00100000 01100100 01101001 01110011 01100101 11110001 01101111 01110011 00100000 01100100 01100101 00100000 01100011 01110101 01100001 01100100 01110010 01101111 00100000 01100100 01100101 00100000 01110100 01100101 01111000 01110100 01101111 00100000 01110001 01110101 01100101 00100000 01110011 01100101 00100000 01100011 01101111 01101101 01110000 01101100 01100101 01101101 01100101 01101110 01110100 01100001 01101110 00100000 01100101 01101110 01110100 01110010 01100101 00100000 01110011 11101101 00101110 00100000 01010000 01101111 01110010 00100000 01100101 01101010 01100101 01101101 01110000 01101100 01101111 00101100 00100000 01110000 01110101 01100101 01100100 01100101 00100000 01100001 01100111 01110010 01100101 01100111 01100001 01110010 00100000 01110101 01101110 01100001 00100000 01110000 01101111 01110010 01110100 01100001 01100100 01100001 00100000 01100011 01101111 01101001 01101110 01100011 01101001 01100100 01100101 01101110 01110100 01100101 00101100 00100000 01100101 01101100 00100000 01100101 01101110 01100011 01100001 01100010 01100101 01111010 01100001 01100100 01101111 00100000 01111001 00100000 01101100 01100001 00100000 01100010 01100001 01110010 01110010 01100001 00100000 01101100 01100001 01110100 01100101 01110010 01100001 01101100 00101110 00100000 01001000 01100001 01100111 01100001 00100000 01100011 01101100 01101001 01100011 00100000 01100101 01101110 00100000 01001001 01101110 01110011 01100101 01110010 01110100 01100001 01110010 00100000 01111001 00100000 01100101 01101100 01101001 01101010 01100001 00100000 01101100 01101111 01110011 00100000 01100101 01101100 01100101 01101101 01100101 01101110 01110100 01101111 01110011 00100000 01110001 01110101 01100101 00100000 01100100 01100101 01110011 01100101 01100101 00100000 01100100 01100101 00100000 01101100 01100001 01110011 00100000 01100100 01101001 01110011 01110100 01101001 01101110 01110100 01100001 01110011 00100000 01100111 01100001 01101100 01100101 01110010 11101101 01100001 01110011 00101110 00001010 01001100 01101111 01110011 00100000 01110100 01100101 01101101 01100001 01110011 00100000 01111001 00100000 01100101 01110011 01110100 01101001 01101100 01101111 01110011 00100000 01110100 01100001 01101101 01100010 01101001 11101001 01101110 00100000 01100001 01111001 01110101 01100100 01100001 01101110 00100000 01100001 00100000 01101101 01100001 01101110 01110100 01100101 01101110 01100101 01110010 00100000 01110011 01110101 00100000 01100100 01101111 01100011 01110101 01101101 01100101 01101110 01110100 01101111 00100000 01100011 01101111 01101111 01110010 01100100 01101001 01101110 01100001 01100100 01101111 00101110 00100000 01000011 01110101 01100001 01101110 01100100 01101111 00100000 01101000 01100001 01100111 01100001 00100000 01100011 01101100 01101001 01100011 00100000 01100101 01101110 00100000 01000100 01101001 01110011 01100101 11110001 01101111 00100000 01111001 00100000 01110011 01100101 01101100 01100101 01100011 01100011 01101001 01101111 01101110 01100101 00100000 01110101 01101110 00100000 01110100 01100101 01101101 01100001 00100000 01101110 01110101 01100101 01110110 01101111 00101100 00100000 01100011 01100001 01101101 01100010 01101001 01100001 01110010 11100001 01101110 00100000 01101100 01100001 01110011 00100000 01101001 01101101 11100001 01100111 01100101 01101110 01100101 01110011 00101100 00100000 01100111 01110010 11100001 01100110 01101001 01100011 01101111 01110011 00100000 01111001 00100000 01100111 01110010 11100001 01100110 01101001 01100011 01101111 01110011 00100000 01010011 01101101 01100001 01110010 01110100 01000001 01110010 01110100 00100000 01110000 01100001 01110010 01100001 00100000 01110001 01110101 01100101 00100000 01100011 01101111 01101001 01101110 01100011 01101001 01100100 01100001 01101110 00100000 01100011 01101111 01101110 00100000 01100101 01101100 00100000 01101110 01110101 01100101 01110110 01101111 00100000 01110100 01100101 01101101 01100001 00101110 00100000 01000001 01101100 00100000 01100001 01110000 01101100 01101001 01100011 01100001 01110010 00100000 01101100 01101111 01110011 00100000 01100101 01110011 01110100 01101001 01101100 01101111 01110011 00101100 00100000 01101100 01101111 01110011 00100000 01110100 11101101 01110100 01110101 01101100 01101111 01110011 00100000 01100011 01100001 01101101 01100010 01101001 01100001 01101110 00100000 01110000 01100001 01110010 01100001 00100000 01100011 01101111 01101001 01101110 01100011 01101001 01100100 01101001 01110010 00100000 01100011 01101111 01101110 00100000 01100101 01101100 00100000 01101110 01110101 01100101 01110110 01101111 00100000 01110100 01100101 01101101 01100001 00101110 00001010 01000001 01101000 01101111 01110010 01110010 01100101 00100000 01110100 01101001 01100101 01101101 01110000 01101111 00100000 01100101 01101110 00100000 01010111 01101111 01110010 01100100 00100000 01100011 01101111 01101110 00100000 01101110 01110101 01100101 01110110 01101111 01110011 00100000 01100010 01101111 01110100 01101111 01101110 01100101 01110011 00100000 01110001 01110101 01100101 00100000 01110011 01100101 00100000 01101101 01110101 01100101 01110011 01110100 01110010 01100001 01101110 00100000 01100100 01101111 01101110 01100100 01100101 00100000 01110011 01100101 00100000 01101110 01100101 01100011 01100101 01110011 01101001 01110100 01100101 01101110 00101110 00100000 01010000 01100001 01110010 01100001 00100000 01100011 01100001 01101101 01100010 01101001 01100001 01110010 00100000 01101100 01100001 00100000 01100110 01101111 01110010 01101101 01100001 00100000 01100101 01101110 00100000 01110001 01110101 01100101 00100000 01110011 01100101 00100000 01100001 01101010 01110101 01110011 01110100 01100001 00100000 01110101 01101110 01100001 00100000 01101001 01101101 01100001 01100111 01100101 01101110 00100000 01100101 01101110 00100000 01100101 01101100 00100000 01100100 01101111 01100011 01110101 01101101 01100101 01101110 01110100 01101111 00101100 00100000 01101000 01100001 01100111 01100001 00100000 01100011 01101100 01101001 01100011 00100000 01111001 00100000 01100001 01110000 01100001 01110010 01100101 01100011 01100101 01110010 11100001 00100000 01110101 01101110 00100000 01100010 01101111 01110100 11110011 01101110 00100000 01100100 01100101 00100000 01101111 01110000 01100011 01101001 01101111 01101110 01100101 01110011 00100000 01100100 01100101 00100000 01100100 01101001 01110011 01100101 11110001 01101111 00100000 01101010 01110101 01101110 01110100 01101111 00100000 01100001 00100000 01101100 01100001 00100000 01101001 01101101 01100001 01100111 01100101 01101110 00101110 00100000 01000011 01110101 01100001 01101110 01100100 01101111 00100000 01110100 01110010 01100001 01100010 01100001 01101010 01100101 00100000 01100101 01101110 00100000 01110101 01101110 01100001 00100000 01110100 01100001 01100010 01101100 01100001 00101100 00100000 01101000 01100001 01100111 01100001 00100000 01100011 01101100 01101001 01100011 00100000 01100100 01101111 01101110 01100100 01100101 00100000 01100100 01100101 01110011 01100101 01100101 00100000 01100001 01100111 01110010 01100101 01100111 01100001 01110010 00100000 01110101 01101110 01100001 00100000 01100110 01101001 01101100 01100001 00100000 01101111 00100000 01100011 01101111 01101100 01110101 01101101 01101110 01100001 00100000 01111001 00101100 00100000 01100001 00100000 01100011 01101111 01101110 01110100 01101001 01101110 01110101 01100001 01100011 01101001 11110011 01101110 00101100 00100000 01101000 01100001 01100111 01100001 00100000 01100011 01101100 01101001 01100011 00100000 01100101 01101110 00100000 01100101 01101100 00100000 01110011 01101001 01100111 01101110 01101111 00100000 01101101 11100001 01110011 00101110 00001010

ENCRIPTAR EN HEXADECIMAL

45 6c 20 76 c3 ad 64 65 6f 20 70 72 6f 70 6f 72 63 69 6f 6e 61 20 75 6e 61 20 6d 61 6e 65 72 61 20 65 66 69 63 61 7a 20 70 61 72 61 20 61 79 75 64 61 72 6c 65 20 61 20 64 65 6d 6f 73 74 72 61 72 20 65 6c 20 70 75 6e 74 6f 2e 20 43 75 61 6e 64 6f 20 68 61 67 61 20 63 6c 69 63 20 65 6e 20 56 c3 ad 64 65 6f 20 65 6e 20 6c c3 ad 6e 65 61 2c 20 70 75 65 64 65 20 70 65 67 61 72 20 65 6c 20 63 c3 b3 64 69 67 6f 20 70 61 72 61 20 69 6e 73 65 72 74 61 72 20 64 65 6c 20 76 c3 ad 64 65 6f 20 71 75 65 20 64 65 73 65 61 20 61 67 72 65 67 61 72 2e 20 54 61 6d 62 69 c3 a9 6e 20 70 75 65 64 65 20 65 73 63 72 69 62 69 72 20 75 6e 61 20 70 61 6c 61 62 72 61 20 63 6c 61 76 65 20 70 61 72 61 20 62 75 73 63 61 72 20 65 6e 20 6c c3 ad 6e 65 61 20 65 6c 20 76 c3 ad 64 65 6f 20 71 75 65 20 6d 65 6a 6f 72 20 73 65 20 61 64 61 70 74 65 20 61 20 73 75 20 64 6f 63 75 6d 65 6e 74 6f 2e 0d 0a 50 61 72 61 20 6f 74 6f 72 67 61 72 20 61 20 73 75 20 64 6f 63 75 6d 65 6e 74 6f 20 75 6e 20 61 73 70 65 63 74 6f 20 70 72 6f 66 65 73 69 6f 6e 61 6c 2c 20 57 6f 72 64 20 70 72 6f 70 6f 72 63 69 6f 6e 61 20 65 6e 63 61 62 65 7a 61 64 6f 73 2c 20 70 69 65 73 20 64 65 20 70 c3 a1 67 69 6e 61 2c 20 70 c3 a1 67 69 6e 61 73 20 64 65 20 70 6f 72 74 61 64 61 20 79 20 64 69 73 65 c3 b1 6f 73 20 64 65 20 63 75 61 64 72 6f 20 64 65 20 74 65 78 74 6f 20 71 75 65 20 73 65 20 63 6f 6d 70 6c 65 6d 65 6e 74 61 6e 20 65 6e 74 72 65 20 73 c3 ad 2e 20 50 6f 72 20 65 6a 65 6d 70 6c 6f 2c 20 70 75 65 64 65 20 61 67 72 65 67 61 72 20 75 6e 61 20 70 6f 72 74 61 64 61 20 63 6f 69 6e 63 69 64 65 6e 74 65 2c 20 65 6c 20 65 6e 63 61 62 65 7a 61 64 6f 20 79 20 6c 61 20 62 61 72 72 61 20 6c 61 74 65 72 61 6c 2e 20 48 61 67 61 20 63 6c 69 63 20 65 6e 20 49 6e 73 65 72 74 61 72 20 79 20 65 6c 69 6a 61 20 6c 6f 73 20 65 6c 65 6d 65 6e 74 6f 73 20 71 75 65 20 64 65 73 65 65 20 64 65 20 6c 61 73 20 64 69 73 74 69 6e 74 61 73 20 67 61 6c 65 72 c3 ad 61 73 2e 0d 0a 4c 6f 73 20 74 65 6d 61 73 20 79 20 65 73 74 69 6c 6f 73 20 74 61 6d 62 69 c3 a9 6e 20 61 79 75 64 61 6e 20 61 20 6d 61 6e 74 65 6e 65 72 20 73 75 20 64 6f 63 75 6d 65 6e 74 6f 20 63 6f 6f 72 64 69 6e 61 64 6f 2e 20 43 75 61 6e 64 6f 20 68 61 67 61 20 63 6c 69 63 20 65 6e 20 44 69 73 65 c3 b1 6f 20 79 20 73 65 6c 65 63 63 69 6f 6e 65 20 75 6e 20 74 65 6d 61 20 6e 75 65 76 6f 2c 20 63 61 6d 62 69 61 72 c3 a1 6e 20 6c 61 73 20 69 6d c3 a1 67 65 6e 65 73 2c 20 67 72 c3 a1 66 69 63 6f 73 20 79 20 67 72 c3 a1 66 69 63 6f 73 20 53 6d 61 72 74 41 72 74 20 70 61 72 61 20 71 75 65 20 63 6f 69 6e 63 69 64 61 6e 20 63 6f 6e 20 65 6c 20 6e 75 65 76 6f 20 74 65 6d 61 2e 20 41 6c 20 61 70 6c 69 63 61 72 20 6c 6f 73 20 65 73 74 69 6c 6f 73 2c 20 6c 6f 73 20 74 c3 ad 74 75 6c 6f 73 20 63 61 6d 62 69 61 6e 20 70 61 72 61 20 63 6f 69 6e 63 69 64 69 72 20 63 6f 6e 20 65 6c 20 6e 75 65 76 6f 20 74 65 6d 61 2e 0d 0a 41 68 6f 72 72 65 20 74 69 65 6d 70 6f 20 65 6e 20 57 6f 72 64 20 63 6f 6e 20 6e 75 65 76 6f 73 20 62 6f 74 6f 6e 65 73 20 71 75 65 20 73 65 20 6d 75 65 73 74 72 61 6e 20 64 6f 6e 64 65 20 73 65 20 6e 65 63 65 73 69 74 65 6e 2e 20 50 61 72 61 20 63 61 6d 62 69 61 72 20 6c 61 20 66 6f 72 6d 61 20 65 6e 20 71 75 65 20 73 65 20 61 6a 75 73 74 61 20 75 6e 61 20 69 6d 61 67 65 6e 20 65 6e 20 65 6c 20 64 6f 63 75 6d 65 6e 74 6f 2c 20 68 61 67 61 20 63 6c 69 63 20 79 20 61 70 61 72 65 63 65 72 c3 a1 20 75 6e 20 62 6f 74 c3 b3 6e 20 64 65 20 6f 70 63 69 6f 6e 65 73 20 64 65 20 64 69 73 65 c3 b1 6f 20 6a 75 6e 74 6f 20 61 20 6c 61 20 69 6d 61 67 65 6e 2e 20 43 75 61 6e 64 6f 20 74 72 61 62 61 6a 65 20 65 6e 20 75 6e 61 20 74 61 62 6c 61 2c 20 68 61 67 61 20 63 6c 69 63 20 64 6f 6e 64 65 20 64 65 73 65 65 20 61 67 72 65 67 61 72 20 75 6e 61 20 66 69 6c 61 20 6f 20 63 6f 6c 75 6d 6e 61 20 79 2c 20 61 20 63 6f 6e 74 69 6e 75 61 63 69 c3 b3 6e 2c 20 68 61 67 61 20 63 6c 69 63 20 65 6e 20 65 6c 20 73 69 67 6e 6f 20 6d c3 a1 73 2e

PROGRAMA CIFRADO CESAR

#include <stdio.h>

#include <stdlib.h>

#include <iostream>

using namespace std;

void menu(int &opcion)

{

printf("Que desea hacer:\n\n1.-Encriptar\n2.-Desencriptar\n3.-Salir\n\nElige opcion:");

scanf("%d",&opcion);

}

void pedir(char palabra[1000],int &num)

{

printf("Introduce la palabra, frase o texto que desees encriptar: ");

fflush(stdin);

cin.getline(palabra,1000);

printf("Introduce el numero de des/codificacion: ");

scanf("%d",&num);

}

void desencriptar(char palabra[1000],int num)

{

int i=0;

while(palabra[i]!='\0')

{

palabra[i]=palabra[i]-num;

i++;

}

printf("\nLa palabra, frase o texto desencriptado es:\n\n%s\n\n",palabra);

}

void encriptar(char palabra[1000],int num)

{

int i=0;

char letra;

while(palabra[i]!='\0')

{

palabra[i]=palabra[i]+num;

i++;

}

printf("\nLa palabra, frase o texto encriptado es:\n\n%s\n\n",palabra);

i=2;

while(i!=1)

{

printf("Deseas (D)esencriptarlo o (C)ontinuar? ");

fflush(stdin);

scanf("%c",&letra);

letra = tolower(letra);

if(letra=='d')

{

desencriptar(palabra, num);

i=1;

}

else if(letra=='c')

{

i=1;

}

else

{

printf("La letra introducida es incorrecta");

}

int main()

{

char palabra[1000];

int num,opcion;

bool i=false;

system("Title Cifrado Cesar");

printf("Este programa se basa en el cifrado <cesar>.\n\n");

while(i!=true)

{

menu(opcion);

system("cls");

if(opcion==1)

{

pedir(palabra, num);

encriptar(palabra, num);

}

else if(opcion==2)

{

pedir(palabra, num);

desencriptar(palabra, num);

}

else if(opcion==3)

{

printf("\t#####################\n\t#programmed by Tr3m0#\n\t#####################\n\n Divide et impera | Veni, vidi, vici.\n\n presiona una tecla para salir.");

fflush(stdin);

getchar();

i=true;

}

return 0;

}