Lenguaje "LSL" - Algoritmos

PRIMERA ENTREGA:

Primero daré unas definiciones para familiarizarnos con el tema:

* Problema:- limite que impide el desarrollo , factor no Deseado

* O.S =>"kernel":- controla los dispositivos "sistema operativo"

* Lenguaje de programación:- define sintaxis y semantica para escribir programas que comunican al usuario con la máquina

existen lenguajes de bajo nivel, medio y alto nivel.

ejemplo de bajo nivel:

PUSH, AX

ADD, AX

POP, AX

ejmplo alto nivel:

for (i=0;i<10;i++)

{

printf("nEste es un ejemplo");

}

* Analisis: "descomposición " de un problema

* requerimientos: FUNCIONALES- define las funciones que el sistema sera capaz de realizar estos deben definir los procesos y actividades que componen el sistema completo

NO FUNCIONALES- son aquellos que no estan relacionados directmente con los procesos que define el sistema

* modelo del mundo: básicamente es trasformar un problema del mundo real a un mundo virtual "sistemas"

* desarrollo de un programa:

[ANALISIS]

[DISEÑO]

[IMPLEMENTACION]

[MANTENIMIENTO]

[DOCUMENTACION]

--------------------------------------------------------------------------------

Estructura de un programa:

"SEUDOCODIGO "HOLA_MUNDO"

inicio

escribir("hola mundo") //muestra por pantalla hola mundo

fin

Como vemos la estructura de un programa consta por un inicio, las sentencias, tambien poseen unas variables.

definición de variable: es un date que cambia constantemente, un espacio en memoria que aloja el dato almacenado, pertenece a un conjunto de datos.

Existen varios tipos de variables tales como

-enteros

-reales

-carácter

-logico / boleano

que en lenguaje de programación son:

entero - int, short, long, byte

real - float, double

caracter - char

logico - boolean

cada uno establecido por un valor en memoria:

teniendo:

byte = (00000000) 8 bits

teniendo encuenta esto tenemos:

byte = 8 bits

int = 4 byte

short = 2 byte

long = 8 byte

float = 4 byte

double = 8 byte

char = 1 byte ACII => americano

2 byte UNICODE => estandar multilenguaje

boolean = 1 byte

--------------------------------------------------------------------------------
Tenemos, que un programa posee unas entradas y unas salidas, las entradas son todas aquellas que el usuario ingresa o que se establecen desde el mismo programa, las salidas son todas aquellas que arrojan un resultado, o un valor, "lo que se muestra por pantalla", un proceso es una acción que se ejecuta, teniendo encuenta veamos un ALGORITMO que lo represente:

* problema: mayor de tres numeros "enteros"

variables... a, b, c

-entradas: a, b, c "pre condición"

-salidas: r "pos condición"

Tenemos entonses el siguiente algoritmo:

si a > b entonces

r = a

sino

r = b

si c > r entonces

r = c

--------------------------------------------------------------------------------

CASOS PARA TENER EN CUENTA:

1) Analizar el problema

2) Describir entradas

3) Describir salidas

4) Explorar casos

5) Realizar algoritmo

6) Prueba de escritorio

7) Montar en lenguaje

DESCRIPCION DE UN ALGORITMO:

Es una serie de instrucciones lógicas en un orden específico y finitas, para resolver un problema:

CONSTA DE: principio, procesos, entradas y salidas.

MEMORIA RAM:

_________________

| |___|

| heap |___|

| [ ] |___| V. locales

| |___|

|____________|___|

HAY variables locales y globales, las globales se almacenan de manera independiente.

en el espacio mayor se almacenan la globales, el

"heap" almacena funciones, los cuadros mas pequeños son donde se almacenan las variables locales.

QUE SON LAS VARIABLES:

como explique anteriormente es donde se almacena un tipo de dato. Estas variables se dividen en "locales" y "globales":

Locales:: son aquellas que estan dentro de un programa, o dentro de un ciclo y solo existen dentro de tal.

Globales:: son todas aquellas que estan en un programa principal, y pueden ser llamadas desde cualquier subprograma.

ESTRUCTURA SECUENCIAL:

Permite representar las instrucciones que se repiten una tras otra, tambien se puede decir que son instrucciones seguidas:

REPRESENTACION:

inicio

<instrucción 1 >

<instrucción 2 >

<instrucción 3 >

<instrucción N >

fín

ejercicio:

Realizar un algoritmo que dados dos números diferentes de un rectangulo encuentre el perímetro y el área

-ENTRADAS:

* valor de un lado

* valor del otro lado

-SALIDAS:

* valor del perimetro

* valor del área del rectángulo

-PROCESO:

Cálculos para obtener el perímetro y el área,

* perímetro = suma de los cuatro lados del rectangulo

* área = lado de la base y lado de la altura

-VARIABLES:

L1 = valor del lado base

L2 = valor del lado áltura

P = perímetro

A = área

SEUDOCODIGO:

inicio

lea: (L1, L2)

p= 2*L1+2*L2

A= L1*L2

escribir ("el perímetro es:",p)

escribir ("el área es:",A)

fín

EJERCICIO:

Hallar dados dos numeros cual es mayor, igual ó menor

-ENTRADA:

*valores de A y B

-SALIDA:

*mensaje que dice si es: mayor, menor, ó igual

-PROCESO

*comparar A con B

--------------------------------------------------------------------------------

SEUDOCODIGO

inicio

lea: A,B

si A > B entonces

escribir ("A es mayor")

sino

si A = B entonces

escribir ("A es igual a B")

sino

escriba ("A es menor que B")

fin_si

fin

--------------------------------------------------------------------------------

Como nos podemos dar cuenta, todo tiene un inicio y tiene un fin para concluir. es importante fijarse en esto, el seudocodigo anterios nos podemos dar cuenta que se utiliza un si y un fin_si para concluir, al igual que un inicio y un fin, esto en un lenguaje de programacion en el caso de C/C++ y java se representa con un corchete. { }

el (SI) es un condicional lógico, que realiza una acción de falso o verdadero.

Este problema se puede resolver mediante ciclos tales como:

para (sentencias)

mientras (sentencias)

hacer (-codigo-) mientras que (sentencias)

si (-código-) sino (--)

pero eso se explicara mas adelante...

Estructura repetitiva:

hasta ahora hemos visto que las instrucciones solo se ejecutan una sola ves con las estructuras repetitivas o ciclos podemos ejecutar una acción las veces que se desee o que necesitemos.

veamos el caso del "mientras" o "mientras que"

MIENTRAS <expresión lógica> haga

fín mientras

--------------------------------------------------------------------------------

HACER <expresión lógica>

mientras que

fín mientras

FUNCIONAMIENTO:

mientras = realiza una acción determinando su expresión lógica, cuya acción esta determinada por la secuencia

hacer mientras que = realiza una acción y luego determina hasta donde esta realizada dicha acción, mientras que cumple su ciclo y despues finaliza

EJEMPLO:

sumar los 5 primeros números naturales

ENTRADA:

*los 5 números

SALIDA:

*suma de los números

VARIBLES: núm y suma

----------------------------------------

inicio

num=0

suma=0

mientras (núm < 5) haga

num=núm+1

suma=suma+núm

fín mientras

escribir ("la suma es:",suma)

fín
---------------------------------------------

ESTRUCTURAS ADICIONALES

LOS CASOS O SELECCION MULTIPLE:

permite seleccionar una opción dentro de un margen de alternativas

REPRESENTACION:

casos de <variable>

caso 1

casos 2

---

caso N

casos: <secuencia N+1>

fin casos

--------------------------------------------------------------------------------

ejemplo:

caso de A:

caso 1 (A=A+1)

escriba ("A")

caso 2 (A=A+2)

escriba ("A")

caso 3 (A=A+3)

escriba ("A")

otros

casos: escriba ("A")

fin casos

--------------------------------------------------------------------------------

SUBPROGRAMAS

como hemos visto anteriormente hay un único programa a desarrollar pero que cuando tenemos que implementar varias funciones y diferentes, pues bueno, como vemos con cualquier aplicacion que utilicemos en nuestro "kernel" un programa cumple varias funciones, pero esto esta dado por varios subprogramas.

Un subprograma puede llamar a otro y visceversa.

REPRESENTACION DE UN SUBPROGRAMA

procedimiento - nombre- (parametro)

fin_nombre

ARREGOLA - ARRAY

anteriormente se vio una variable como un unico campo de almacanamiento en memoria, la cual establecemos un valor y permanese a no ser que se modifique, pero esto esta bien, pero no nos sirve para cuando nosotros queremos crear. una base de datos de 100 espasios en memoria, no podemos colocar (E1,E2,E3,E4,...,E100) nos ocupa mucha memoria y nos tomaria mucho tiempo.

ARREGLOS

Un arreglo o vector es donde se guardan varias variables en un solo campo, en fila o columna.

EJEMPLO:

________

[][][][]|

¬¬¬¬¬¬¬¬

esto seria graficamente para entenderlo mejor

EJEMPLO DE UN VECTOR O ARREGLO

si queremos colocar las edades de un grupo, especificamos el tamaño del vector y la longitud.

lo que esto realiza es lo siguiente

--------------------------------------------------------------------------------

MEMORIA

edad[1] <relleno> direccion x

edad[2] <relleno> direccion x+1

edad[3] <relleno> direccion x+2

edad[4] <relleno> direccion x+3

cada variable es independiente

lea: edad[1], edad[2], edad[4]:

escribir ("edad[1], edad[4]")

RETOMANDO LAS EDADES

quedaria en memoria asi:

edad[1] <12> direccion x

edad[2] <44> direccion x+1

edad[3] <basura> direccion x+2

edad[4] <23> direccion x+3

para borrar los campos del vector

solucion:

--------------------------------------------------------------------------------

UTILIZANDO MIENTRAS

inicio

indice = 1

mientras indice <=5 haga

edad [indice]=0

indice=indice+1

fin mientras

fin

--------------------------------------------------------------------------------

REGISTROS Y ARCHIVOS:

es una estructura de datos compuesta. se puede decir que un registro es un conjunto de campos variables relacionados, que en general, pueden pertenecer a tipos de datos diferentes.

ejemplo:

[<nombre>]

[<edad>]

[<cedula>]

se emplea mediante una estructura (struct)

por lo que en C/C++ se definiria asi:

struct persona

{

long cc;

char nom [40];

int edad;

}

Donde [40]

es el tamaño o el numero de pocisiones que le daremos a este struct

______________________________________...

RECUERDA:

repasa lo planteado anterior mente, no te conformes con esta información solo te estoy dando un guia para que puedas buscar y aprender.

AHORA:

realicemos unos ejercicios para que practiques y mas adelante poder pasar el codigo a un lenguaje

trata de realizar los ejercicios planteados sin ver la respuesta.

DEFINICION DE CONSTANTE: una variable constente es la que se le determina un valor y lo conserva hasta el fin del programa a no ser que dicho valor sea cambiado despues

----------------------------------------...
1) REALICEMOS UN SEUDOCODIGO QUE DIGA QUE NUMERO ES MAYOR TENIENDO EN CUENTA QUE EL USUARIO DIGITE UN NUMERO Y SEA COMPARADO CON VALRO=5.

----------------------------------------...
2) PREGUNTAR AL USUARIO UN NUMERO HASTA QUE ESCRIBA UNO (>30)

----------------------------------------...
3) REALIZAR UN JUEGO EL CUAL EL USUARIO INGRSE UN NUMERO Y OTRO USUARIO LO TENGA QUE ADIVINAR Y QUE EL SISTEMA TE DE PISTAS PARA PODER DESCUBRIR EL NUMERO DEL PRIMER USUARIO

----------------------------------------...
----------------------------------------...
----------------------------------------...
RESPUESTA A LOS PROBLEMAS:

inicio

constante real valor=5

real x

escribir ("deme x")

leer (x)

si (x> valor)

escribir ("es mayor que 5")

si (x< valor)

escribir ("es menor que 5")

sino
escribir ("es igual que 5")

fin
fin
fin

----------------------------------------...
2)

inicio

entero n

escribir ("digite un número")

leer (n)

mientras que (n<30)hacer

escribir ("digite un numero de nuevo")

fin

----------------------------------------...
3)

inicio

entero a,b

escribir ("usuario uno digite un numero")

leer (a)

escribir ("usuario dos adivine el numero de usuario uno")

leer (b)

mientras (b>a)hacer

escribir ("el numero es mayor que el primero")

fin

mientras (b<a)hacer

escribir ("el numero es menor que el primero")

fin

si (a=b)

escribir ("el nuemro es correcto")

fin

--------------------------------------------------------------------------------

AHORA VEAMOS UN EJEMPLO DE SUBPROGRAMA

programa principál

seudocodigo x

inicio

subprograma_y()

subprograma_w()

subprograma_k()

fin

EJEMPLO:

Hagamos un programa que sume los numeros ingresados por el usuario y que despues el programa pirncipal llame al subprograma suma y el resultado de la suma lo multiplique por dos, le pida un nuevo número al usuario y lo divida por el resultado. y muestre el valor obtenido por pantalla.

aplicando el concepto de variable global y local, y mirando que podemos reasignar un valor a una variable.

----------------------------------------...
subprograma_suma

inicio

entero n1,n2

escribir ("ingrese un numero")

leer (n1)

escribir ("ingrese un otro numero")

leer (n2)

respuesta = n1+n2

fin

programa_principal

inicio

   entero respuesta, div, acumulador
   escribir ("ingrese un numero para dividir")
   leer (div)

acumulador = subprograma(respuesta)*2

acumulador = acumulador / div

escribir ("el valor obtenido es:",acumulador)

fin

:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
como podemos apreciar el primer codigo es el de el subprograma y el segundo el del programa principal, el cual llama al subprograma, coje el valor que le dio lo establece en (respuesta) por que es la funcion que estamos llamando lo multiplica por dos y el resultado lo pasa a acumulador que le damos el valor de acumulador dividido en el numero ingresado y nos da un valor entero.

el caso de dar a una variable el valor de la misma variable se aplica en casos parecidos, esto toma el valor que ya tenia y lo cambia por una nueva instruccion, en el caso de contador es el valor que le dio dividido y el resultado es el mismo acumulador.

--------------------------------------------------------------------------------

MIREMOS UN FOR.

un for es un para, osea efectua una accion para la sentencia determinada entrando dentro de la terminología ciclo.

ejemplo:

para (i=1;i<=k;i++)

lo que realiza esta secuencia es que la variable (i) empieza en uno y se incrementa de a uno hasta llegar a la variable (k)

despues se puede colocar la accion a realizar o la instrucción

ejemplo:

para (i=1;i<=k;i++)

inicio

escribir("numero:",i)

fin

--------------------------------------------------------------------------------

AHORA MIREMOS LO QUE ES UN FOR ANIDADO

como se entiende es un for dentro de otro for, osea una estructura para dentro de otra.

ejemplo:

para(i=0;i>k;i++)

inicio

para(j=100:j<=i;j--)

inicio

fin

Bueno hasta aca llega la primera parte de algoritmia.

apartir de este momento nos vamos a empesar a meter en el codigo de LSL con casos