LENGUAJES

1. QUE ES UN LENGUAJE DE PROGRAMACION

En informática, se conoce como lenguaje de programación a un programa destinado a la

construcción de otros programas informáticos. Su nombre se debe a que comprende un
lenguaje formal que está diseñado para organizar algoritmos y procesos lógicos que serán
luego llevados a cabo por un ordenador o sistema informático, permitiendo controlar así su
comportamiento físico, lógico y su comunicación con el usuario humano.

Dicho lenguaje está compuesto por símbolos y reglas sintácticas y semánticas, expresadas en
forma de instrucciones y relaciones lógicas, mediante las cuales se construye el código fuente
de una aplicación o pieza de software determinado. Así, puede llamarse también lenguaje de
programación al resultado final de estos procesos creativos.

La implementación de lenguajes de programación permite el trabajo conjunto y coordinado,

a través de un conjunto afín y finito de instrucciones posibles, de diversos programadores o
arquitectos de software, para lo cual estos lenguajes imitan, al menos formalmente, la lógica
de los lenguajes humanos o naturales.

No deben confundirse, sin embargo, con los distintos tipos de lenguaje informático. Estos
últimos representan una categoría mucho más amplia, en donde están contenidos
los lenguajes de programación y muchos otros protocolos informáticos, como el HTML de
las páginas web.

2.- NIVELES DE LOS LENGUAJES

Lenguajes de bajo nivel

Son lenguajes totalmente dependientes de la máquina, es decir que el programa que se

realiza con este tipo de lenguajes no se pueden migrar o utilizar en otras maquinas.

Al estar prácticamente diseñados a medida del hardware, aprovechan al máximo las

características del mismo.

Dentro de este grupo se encuentran:

El lenguaje maquina: este lenguaje ordena a la máquina las operaciones fundamentales para
su funcionamiento. Cnsiste en la combinación de 0's y 1's para formar las ordenes
entendibles por el hardware de la maquina.
Este lenguaje es mucho más rápido que los lenguajes de alto nivel.
La desventaja es que son bastantes difíciles de manejar y usar, además de tener códigos
fuente enormes donde encontrar un fallo es casi imposible.
El lenguaje ensamblador es un derivado del lenguaje maquina y esta formado por
abreviaturas de letras y números llamadas mnemotécnicos. Con la aparición de este lenguaje
se crearon los programas traductores para poder pasar los programas escritos en lenguaje
ensamblador a lenguaje máquina. Como ventaja con respecto al código máquina es que los
códigos fuentes eran más cortos y los programas creados ocupaban menos memoria. Las
desventajas de este lenguaje siguen siendo prácticamente las mismas que las del lenguaje
ensamblador, ñadiendo la dificultad de tener que aprender un nuevo lenguaje difícil de
probar y mantener.

Lenguajes de alto nivel

Son aquellos que se encuentran más cercanos al lenguaje natural que al lenguaje máquina.

Se tratan de lenguajes independientes de la arquitectura del ordenador. Por lo que, en

principio, un programa escrito en un lenguaje de alto nivel, lo puedes migrar de una máquina
a otra sin ningún tipo de problema.

Estos lenguajes permiten al programador olvidarse por completo del funcionamiento interno
de la maquina/s para la que están diseñando el programa. Tan solo necesitan un traductor
que entiendan el código fuente como las características de la maquina.

Suelen usar tipos de datos para la programación y hay lenguajes de propósito general
(cualquier tipo de aplicación) y de propósito especifico (como FORTRAN para trabajos
científicos).

Lenguajes de Medio nivel

Se trata de un termino no aceptado por todos, pero q seguramente habrás oído. Estos
lenguajes se encuentran en un punto medio entre los dos anteriores. Dentro de estos
lenguajes podría situarse C ya que puede acceder a los registros del sistema, trabajar con
direcciones de memoria, todas ellas características de lenguajes de bajo nivel y a la vez
realizar operaciones de alto nivel.

3.- LENGUAJES DE ALTO NIVEL

Un lenguaje de programación de alto nivel se caracteriza por expresar los algoritmos de una
manera adecuada a la capacidad cognitiva humana, en lugar de la capacidad con que los
ejecutan las máquinas. Estos lenguajes permiten una máxima flexibilidad al programador a la
hora de abstraerse o de ser literal. Permiten un camino bidireccional entre el lenguaje
máquina y una expresión casi oral entre la escritura del programa y su posterior compilación.
Por lo general suelen estar orientados a objetos, a eventos o a funciones, pudiendo estos
combinarse. Asimismo, pueden ser compilados o interpretados. Algunos ejemplos
son: Java, PHP, Python, Javascript, C++.
En los primeros lenguajes, la limitación era que se orientaban a un área específica y sus
instrucciones requerían de una sintaxis predefinida. Se clasifican como lenguajes
procedimentales o lenguajes de bajo nivel. Otra limitación de estos es que se requiere de
ciertos conocimientos de programación para realizar las secuencias de instrucciones lógicas.
Los lenguajes de alto nivel se crearon para que el usuario común pudiese solucionar un
problema de procesamiento de datos de una manera más fácil y rápida.

Por esta razón, a finales de los años 1950 surgió un nuevo tipo de lenguajes de programación
que evitaba estos inconvenientes, a costa de ceder un poco en las ventajas. Estos lenguajes
se llaman de tercera generación o de nivel alto, en contraposición a los de bajo nivel o de
nivel próximo a la máquina.

4.- COMPILADORES

En informática, un compilador es un tipo de traductor que transforma un programa entero

de un lenguaje de programación(llamado código fuente) a otro.1 Usualmente el lenguaje
objetivo es código máquina, aunque también puede ser traducido a un código intermedio
(bytecode) o a texto. A diferencia de los intérpretes, los compiladores reúnen diversos
elementos o fragmentos en una misma unidad (un programa ejecutable o una librería), que
puede ser almacenada y reutilizada. Este proceso de traducción se conoce
como compilación.2

La construcción de un compilador involucra la división del proceso en una serie de fases que
variará con su complejidad. Generalmente estas fases se agrupan en dos tareas: el análisis
del programa fuente y la síntesis del programa objeto.

5.- INDIQUE PASO A PASO EL PROCESO O EJECUCION DE UN COMPILADOR

PASOS A SEGUIR PARA EJECUTAR UN PROGRAMA C CON ESTE

COMPILADOR

Para crear un proyecto, un archivo fuente asociado, compilar y ejecutar, se deben seguir

los pasos indicados a continuación.

Para crear un proyecto nuevo:

Aparece la ventana nuevo proyecto, en la que hay que elegir empty project, marcar la

opción En C, y poner un nombre al proyecto. Pulsar aceptar.

y elegir un directorio para guardar el archivo de proyecto

Ahora se crea un archivo fuente asociado al proyecto, de la siguiente forma:

A continuación aparece una pantalla de confirmación. Elegir Yes.

Guardar este archivo en la carpeta donde hayamos guardado el proyecto. (Con este

compilador al crear un proyecto, no se crea por defecto un directorio para ese proyecto,

luego el archivo de proyecto y el archivo fuente se guardarán en un directorio existente

en nuestro disco).

Se abre el editor de texto, en el que tenemos que incluir el código fuente.

IMPORTANTE

Al incluir el código hay unos cambios respecto Visual C:

1- La función main no es de tipo void, sino que es int; por tanto, en lugar de incluir

void main( ) se debe escribir int main ( ) o simplemente main( )

2- Para que la ventana MS-DOS de salida, se mantenga en pantalla, hay que incluir

la orden system(“pause”); antes de cerrar la llave de instrucciones main

A continuación se puede observar un ejemplo escrito en el editor:

Para compilar y linkar (Build) se procede como se indica a continuación

Nos muestra una pantalla del proceso de compilación, indicando el número de errores y

avisos

Para ejecutar el programa:

Para cerrar un proyecto se elige la opción Archivo Cerrar Proyecto

Para abrir un proyecto existente se elige la opción Archivo Abrir proyecto o

archivo y escoger el proyecto que se quiera abrir (extensión dev)

6.- LENGUAJE PASCAL Y EL LENGUAJE DELPHI

Pascal es un lenguaje de programación creado por el profesor suizo Niklaus Wirth entre los años 1968 y
1969 y publicado en 1970. Su objetivo era crear un lenguaje que facilitara el aprendizaje de programación
a sus alumnos, utilizando la programación estructurada y estructuración de datos. Sin embargo con el
tiempo su utilización excedió el ámbito académico para convertirse en una herramienta para la creación
de aplicaciones de todo tipo.
Pascal se caracteriza por ser un lenguaje de programación estructurado fuertemente tipado. Esto implica
que:

1. El código está dividido en porciones fácilmente legibles llamadas funciones o procedimientos. De

esta forma Pascal facilita la utilización de la programación estructurada en oposición al antiguo
estilo de programación monolítica.
2. El tipo de dato de todas las variables debe ser declarado previamente para que su uso quede
habilitado.

Delphi es un entorno de desarrollo de software diseñado para la programación de propósito

general con énfasis en la programación visual. En Delphi se utiliza como lenguaje de
programación una versión moderna de Pascal llamada Object Pascal.

7.- INSTRUCCIONES DE PROGRAMA USADAS POR EL LENGUAJE PASCAL

Eres libre de dar a la variable un nombre descriptivo. Por ejemplo el nombre de

variable telefono es obvio que contendrá algún tipo de número de teléfono.

La sentencia CLRSCR, nos permite borrar la pantalla antes de correr el programa.. Es

primordial limpiar la pantalla cada vez que iniciemos un programa, para que no se vean
líneas de programas anteriores. Para que funcione debes colocar la unidad CRT.

CRT es la primera unidad que trataremos y es la encargada de gestionar (entre otras cosas) la
pantalla en modo texto. Para acceder a cualquier unidad, se emplea la sentencia Uses justo
después de Program y antes de las declaraciones de variables:

Write es la orden que permite escribir un texto en pantalla. El conjunto de todo lo que se
desee escribir se indica entre paréntesis. Cuando se trata de un texto que queremos que
aparezca tal cual, éste se encierra entre comillas (una comilla simple para el principio y otra
para el final).

Writeln, que es exactamente igual que Write con la única diferencia de que después de
visualizar el mensaje, el cursor (la posición en la que se seguiría escribiendo, marcada
normalmente por una rayita o un cuadrado que parpadea) pasa a la línea siguiente, en vez de
quedarse justo después del mensaje escrito.

ReadLee un valor de teclado y lo almacena en la variable

Read (Identificador);

El identificador puede ser cualquier variable definida previamente, NO puede ser una
constante. Puede ser también un conjunto de variables, separadas entre comas, en este caso
se guardara el primer valor dado antes del [Enter] en el primer identificador proporcionado,
luego el segundo y así sucesivamente hasta el último identificador.

La diferencia en el uso de la instrucción Read con respecto a ReadLn es que en la primera, si

se le dan mas datos de los que se introducirán se guardan en un buffer y se usarán en la
siguiente instrucción Read o ReadLn del programa, en cambio ReadLn ignora todo dato
posterior a los que esten definidos en la instrucción.

En caso de que se le indique a Read o ReadLn que lea un tipo específico de valor, y se le
proporcione otro diferente se generará un error y se detendrá la ejecución del programa.

Operaciones básicas

Las operaciones básicas en Turbo Pascal están formadas por dos partes: el operador y los
operandos.

Un operador es el símbolo que le indica al programa que operación realizará y los operandos
son los datos sobre los cuales se efectuará la operación.

Los operadores de Turbo Pascal son:

Operador Operación
+ Suma
- Resta
* Multiplicación
/ División

El tipo de datos que pascal regresa como resultado de una operación dependerá del tipo de
datos usados como operandos. Por ejemplo, la suma de dos enteros da como resultado otro
entero, y la suma de dos números reales da como resultado otro número real.

Operadores DIV y MOD

La división de dos números, sin importar su tipo, dará como resultado un número real, así
que para dividir dos enteros, y obtener el resultado como entero, Turbo Pascal ofrece el
operador DIV, el cual da el resultado entero de una división entre enteros, y el operador
MOD que regresa el residuo de una división de enteros.

Su sintaxis es:

entero := dividendo DIV divisor

entero := dividendo MOD divisor

El siguiente programa es un ejemplo del uso de los operadores aritméticos:

PROGRAM Operaciones_Básicas;

VARSuma, Resta, Multiplicacion, Division : Real; Cociente_Entero, Residuo_Entero :

Integer;

BEGINSuma := 12 + 8;Resta := 12 - 8;Multiplicacion := 12 * 8;Division :=

12/8;Cociente_Entero := 12 DIV 8;Residuo_Entero := 12

MOD 8;WriteLn ('La suma de 12 + 8 es igual a: ',Suma); WriteLn ('La resta de 12 - 8 es igual
a: ',Resta);WriteLn ('La multiplicación de 12 * 8 es igual a: ',Multiplicacion);WriteLn ('La
división de 12 / 8 es igual a: ',Division);WriteLn ('La división entera de 12 / 8 es igual a:
',Cociente_Entero);WriteLn ('El residuo de la división entera de 12 / 8 es:
',Residuo_Entero);

END.

Operadores de Relación

Los operadores relacionales nos sirven para determinar la relación que tiene una expresión
con otra. Los operadores relacionales que manejaremos enPascal son los siguientes:

Operadores Descripción
= Es igual a
<> No es igual a
> Es mayor que
<</b> Es menor que
>= Es mayor o igual que
<= Es menor o igual que
And y
Or o
Not no

Sentencia IF...THEN...ELSE

Esta expresión es utilizada para ejecutar una sentencia en el caso que una condición
establecida sea verdadera, de lo contrario se podra ejecutar una sentencia distinta. Su
sintaxis es:

IF condición THEN instrucción ELSE otro

Donde condición es la expresión que se evaluará, en caso de ser verdadera se ejecutará la
sentencia dada como instrucción, en caso de que la condición sea falsa se ejecutara la
sentencia dada como otro. Ejemplo:

PROGRAM IF_THEN_ELSE;VARContador : Integer;BEGINFOR contador := 1 to 50

DOBEGINIF contador > 10 THEN WriteLn(Contador) ELSE WriteLn('*');END;END.

En este pequeño programa la variable Contador se incrementará desde 1 hasta 50, la

sentencia condicional IF verificará si es verdad que Contador es mayor a 10, de ser así se
escribirá en pantalla el valor de la variable, de lo contrario se escribira en la pantalla un
caracter "*". Como el contador inicia desde 1, tenemos que se imprimiran 10 asteriscos
antres del primer número, que será el 11, valor que si cumple la condición "Contador > 10"
(la hace verdadera).

La sección ELSE con su correspondiente sentencia son opcionales y pueden omitirse en caso
de no necesitarse.

Sentencias IF anidadas

Es posible utilizar en una expresión del tipo IF..THEN..ELSE una sentencia compuesta como la
sentencia a ejecutarse en caso de que la condición sea verdadera, así como en la sentencia
posterior a un ELSE, de esta forma podemos utilizar otra sentencia IF..THEN..ELSE dentro de
la anterior, para de esta forma evaluar varias condiciones una dentro de otra. Ejemplo:

IF Numero > 5 THENBEGINIF Numero <10 THEN Opcion :="Numero; IF Numero <30 THEN
Opcion2 :="Numero; END;

Ciclos FOR

El ciclo FOR repite una sentencia un determinado número de veces que se indica al momento
de llamar al ciclo.

Lo que hace FOR es que incrementa una variable en uno desde un valor inicial hasta un valor
final ejecutando en cada incremento la sentencia que se quiere repetir. Su sintaxis es:

FOR identificador := inicio TO fin DO instrucción;

Donde el identificador es la variable que se incrementará, inicio es el primer valor que tendrá
dicha variable y fin es el valor hasta el cual se incrementará la misma; instrucción es la
sentencia (sencilla o compuesta) que se ejecutará en cada incremento de la variable.

El siguiente ejemplo escribe los números del 1 al 50 en pantalla. La variable utilizada es

"Numero".
PROGRAM Ciclo_FOR;VARNumero : Integer;BEGINFOR Numero := 1 to 50
DOWriteLn(Numero);END.

Una de las limitaciones de los ciclos FOR es que una vez iniciado el ciclo se ejecutará el
número de veces predefinido sin posibilidad de agregar o eliminar ciclos.

Es posible hacer que un ciclo cuente hacia atrás, es decir que la variable en lugar de
incrementarse se decremente. Para ésto cambiamos la palabra TOpor DOWNTO, y
colocamos el valor mayor a la izquierda y el menor a la derecha.

Ejemplo:

PROGRAM Ciclo_FOR_2;VARNumero : Integer;BEGINFOR Numero := 50 DOWNTO 1

DOWriteLn(Numero);END.

Ciclos WHILE

Los ciclos WHILE ofrecen la ventaja de que la ejecución se realiza mientras se cumpla una
condición, por lo tanto es posible controlar el número de repeticiones una vez iniciado el
ciclo. Su sintaxis es:

WHILE condición DO instrucción

Donde condición es la condición que se evaluará, mientras ésta sea verdadera se ejecutará la
instrucción, que es una sentencia simple o compuesta.

Un programa que escriba los números del 1 al 50, utilizando el ciclo WHILE se vería como
sigue:

PROGRAM Ciclo_WHILE;VARNumero : Integer;BEGINNumero := 1;WHILE Numero <= 50

DOBEGINWriteLn (Numero);Numero := Numero +1;END;END.

Al final del programa la variable Numero guardará el valor 51, que fué el valor que no
cumplió con la condición establecida en el ciclo WHILE.

Ciclos REPEAT-UNTIL

Este tipo de ciclos es muy parecido a los ciclos WHILE, la diferencia entre ambos es que en
WHILE la condición se evalúa al principio del ciclo, en cambio en REPEAT-UNTIL se evalúa al
final, lo que significa que en un ciclo REPEAT-UNTIL la sentencia se ejecutará por lo menos
una vez, cosa que puede no ocurrir en el ciclo WHILE. Ejemplo:
PROGRAM Ciclo_RepeatUntil;VARNumero : Integer;BEGINNumero := 1;REPEATWriteLn
(Numero);Numero := Numero + 1;UNTIL Numero = 50;END.

Para crear un buen programa es necesario dotarlo con capacidad de desición con base en las
variables o eventos definidos por el programador, para que el programa sea aplicable en un
entorno más generalizado y no solo para un problema específico.

Selecciones CASE

Esta forma de control se utiliza cuando se va a evaluar una expresión que puede contener
varios datos diferentes y en cada dato deberá realizar una acción especial. Por ejemplo, si se
crea un menú con diferentes opciones se realizará un determinado proceso para cada acción,
aunque la selección por parte del usuario se haga desde el mismo lugar.

El siguiente programa ilustra el uso de la forma CASE, el programa preguntará un número al

usuario y lo clasificará de acuerdo a su valor.

PROGRAM Case;VARNumero : Integer;BEGINWriteLn('Introduzca un número entero del 1

al 5: ');ReadLn(Numero);

CASE Numero OF1 : WriteLn('El número fué 1');2 : WriteLn('El número fué 2');3 :
WriteLn('El número fué 3');4 : WriteLn('El número fué 4');5 : WriteLn('El número fué
5');ELSE WriteLn('El número no estaba en el rango indicado');

END.

GOTO

La sentencia GOTO es una sentencia utilizada para alterar el flujo del programa, es decir, para
ir a ejecutar una sentencia en un lugar diferente del programa y no la linea siguiente.

El uso de GOTO no es aconsejable ya que destruye el modelo de

la programación estructurada que es la que se utiliza en Turbo Pascal, además se cuenta con
las estructuras de datos anteriores que hacen casi innecesario su uso.

Para utilizar este tipo de salto es necesario declarar etiquetas, que no son otra cosa que el
identificador que marcará el lugar a donde se dirigirá el flujo del programa al momento de
usar el GOTO. La declaración de etiquetas se hace antes que la de constantes y variables, la
palabra reservada para su declaración es LABEL. El nombre de la etiqueta es un nombre de
un identificador como cualquier otro, pero al utilizarse debe terminar con dos puntos ":".

La sintaxis del comando es:

GOTO etiqueta;
Ejemplo:

PROGRAM Uso_del_GOTO;LABELEtiqueta;BEGINWriteLn('Esta linea si se escribirá');

GOTO Etiqueta;WriteLn('Esta linea no se escribirá'); Etiqueta:WriteLn('Se efectuó el

brinco');END.

Nota: normalmente se debe agregar la libreria CRT , despues del PROGRAM,

PARA poder usar el comando CLRSCR, Que nos permite borrar la pantalla antes de correr el
programa.

Ejemplos.

Program Suma; {Ejemplo de un programa que Suma}Uses

CRT;Var A,B,Resultado:integer;Begin CLRSCR; Write ('Ingrese primer
numero:'); Readln (A); Write ('Ingrese segundo numero:'); Readln
(B); Resultado:=A+B; Writeln ('El Resultado es:',Resultado); Readln;End.

***********************************************************

PROGRAM EJER2B;

USES CRT;

VAR x,y:REAL;

VAR suma,rest,mult:REAL;

VAR divi:REAL;

{suma, resta, multiplica y divide 2 numeros reales}

BEGIN

WRITELN ('Este programa suma, resta, multiplica y divide:');

WRITELN ('Escriba dos numeros reales');

WRITELN (' ');

Read(x);

Read(y);
suma:=x + y;

rest:=x - y;

mult:=x * y;

divi:=x / y;

ClrScr;

WRITE ('SUMA:'); WRITELN (suma:3:0);

WRITE ('RESTA:'); WRITELN (rest:3:0);

WRITE ('MULTIPLICACION:'); WRITELN (mult:3:0);

WRITE ('DIVISION:'); WRITE (divi:5:2);

END.

******************************************************************

PROGRAM EJER4B;

USES CRT;

VAR base,altura:REAL;

VAR area:REAL;

BEGIN

{Este programa sirve para calcular el area de un triangulo}

ClrScr;

WRITELN ('PARA CALCULAR EL AREA DE UN TRIANGULO:');

WRITELN (' ');

WRITE ('ESCRIBE LA BASE: '); READLN (base);

WRITE ('ESCRIBE LA ALTURA: '); READLN (altura);

WRITELN (' ');

area:=(base * altura) / 2;

WRITE ('EL AREA DEL TRIANGULO ES: '); WRITE (area:5:2);

END.

Program Saludo; Var nombre: string[20]; Begin Writeln ('Introduce tu nombre, por
favor'); Readln (nombre); Write ('Hola ',nombre); Readln;End.

******************************************************

Program AreaCirculo;Uses Crt;Const pi = 3.1415927; {Declaración de

constante}Var area: Real; {Area del círculo} radio: Integer; {Radio a teclear}Begin Write
('Radio: '); ReadLn (radio); area := pi * radio * radio; WriteLn ('Area: ', area);End.

PROGRAM EJER10B;

USES CRT;

VAR a,b,c:REAL;

VAR resultado:REAL;

BEGIN

{Calcula la incognita positiva de una ecuacion de 2º grado}

ClrScr;

WRITE ('Para calcular la incognita positiva de una ecuacion');

WRITE (' de segundo grado escriba todas las variables:');

WRITELN (' ');

WRITELN (' ');

WRITE ('Escriba a: '); READLN (a);

WRITE ('Escriba b; '); READLN (b);

WRITE ('Escriba c; '); READLN (c);

WRITELN (' ');

resultado:=(-b +sqrt(sqr (b) - 4*a*c))/(2*a);

WRITE ('RESULTADO: '); WRITE(resultado:5:2);

END.

PROGRAM EJER15B;

USES CRT;

VAR arista:REAL;

VAR area, volumen:REAL;

BEGIN

{Sirve para calcular el area y el volumen de un tetraedro}

WRITELN ('PARA CALCULAR EL AREA Y VOLUMEN DE UN TETRAEDRO: ');

WRITE ('ESCRIBA EL VALOR DE LA ARISTA: '); READLN (arista);

WRITELN (' ');

area:= 2 * sqr(arista) * sqrt(3);

volumen:= ((sqr(arista) * arista) / 3) * sqrt(2);

WRITE ('AREA DEL OCTAEDRO: '); WRITELN (area:5:2);

WRITE ('VOLUMEN DEL OCTAEDRO: '); WRITE (volumen:5:2);

END.

Program Numeros;Uses CRT;Var numero:integer;Begin CLRSCR; Write ('Escriba un

número: '); Readln (numero); If numero>0 Then Writeln ('El número es
positivo'); Readln;End.

********************************************************

Program Numeros;Uses CRT;Var numero:integer;Begin CLRSCR; Write ('Escriba un

número: '); Readln (numero); If numero<0 Then Writeln ('El número es
negativo') Else Writeln ('El número es positivo o cero'); Readln;End.

**********************************************************
Program Mayor;Uses CRT;Var N1,N2,N3,NMayor:integer;Begin CLRSCR; Write
('Ingrese primer número: '); Readln (N1); Write ('Ingrese segundo número: '); Readln
(N2); Write ('Ingrese tercer número: '); Readln (N3); If (N1>=N2) And (N1>=N3)
Then; NMayor:=N1; If (N2>=N1) And (N2>=N3) Then; NMayor:=N2; If (N3>=N1)
And (N3>=N2) Then; NMayor:=N3; Writeln ('El numero mayor es:
',NMayor); Readln;End.

Program Area;Uses

CRT;Var area,B,H:real; i,num:integer;

Begin CLRSCR;

Writeln ('¿Cuantas areas desea calcular?');

Readln (num);

For i:=1 To num Do

Begin Writeln ('Triangulo #: ',i);

Writeln ('Ingrese base: ');

Readln (B);

Write ('Ingrese altura: ');

Readln (H);

area:=(B*H)/2;

Writeln ('El Area es: ',area:8:4);

End; Readln;End.

Program Sumar;Uses

CRT;Var N,num,cont,suma:integer;

Begin CLRSCR;

Writeln ('¿Cuantas números desea ingresar?');

Readln (N); suma:=0; For cont:=1 To N Do

Begin

Write ('Ingrese numero: ')

Readln (num); suma:=suma+num;

End;

Writeln ('La suma total es: ',suma);

Readln;End.

PROGRAM EJER18B;

USES CRT;

VAR a,b,c:REAL;

VAR resultado1,resultado2:REAL;

BEGIN

{Calcula ecuaciones de segundo grado}

ClrScr;

WRITE ('ESTE PROGRAMA SIRVE PARA CALCULAR ECUACIONES ');

WRITELN ('DE SEGUNDO GRADO');

WRITELN (' ');

WRITELN ('Introduzca: a, b y c: ');

WRITELN (' ');

READLN (a);

READLN (b);

READLN (c);

resultado1:=(-b + sqrt(sqr(b) - 4*a*c)) / (2*a);

resultado2:=(-b - sqrt(sqr(b) - 4*a*c)) / (2*a);

WRITELN ('RESULTADO DE LA EXPRESION: ');

WRITE ('VALOR 1: '); WRITELN (resultado1:5:2);

WRITE ('VALOR 2; '); WRITE (resultado2:5:2);

END.

PROGRAM EJER22B;

USES CRT;

VAR horas, minutos, segundos:INTEGER;

VAR cantidad:INTEGER;

BEGIN

ClrScr;

WRITE ('Escriba los segundos para transformarlo a horas,');

WRITELN (' minutos y segundos');

READLN (cantidad); {Es el numero de segundos que se introducen}

WRITELN ('');

horas:= cantidad div 3600;

minutos:= (cantidad mod 3600) div 60;

segundos:= (cantidad mod 3600) - (minutos * 60);

{Los segundos son: las horas - los minutos pasados a segundos}

WRITELN ('EN ' ,cantidad, ' SEGUNDOS HAY: ');

WRITE (horas,' horas ',minutos,' minutos ',segundos,' segundos');

END.

8.- FORMATO DE LAS INSTRUCCIONES DE ENTRADA –SALIDA : (READ, WHITE, WRITELN() Y

CLRSCR). EJEMPLOS
Los procedimientos de salida de datos: write y writeln
Un programa por simple que sea, va a tener que mostrar cierta información de
salida. Esto se consigue en Pascal mediante los procedimientos write y writeln. En
este apartado, nos centraremos en el estudio de ellos.

Veamos como es la sintaxis de los procedimientos write y writeln, es decir, ¿cuál es

la manera correcta de escribirlos?:

write (ítem, ítem, ...);

writeln (ítem, ítem, ...);

Cada uno de estos ítems puede ser:

 un valor literal
 una constante con nombre
 una variable
 una llamada a una función

nota: Un función especial que tiene writeln es como espaciador entre líneas. Así,
llamando al procedimiento sin ningún parámetro produciremos un salto de línea.
En el siguiente ejemplo puedes observar llamadas a ambos procedimientos que
resumen un poco todo esto que hemos mencionado:

program Prueba_write;
const
iva_factor = 0.16;
var
num_udes : integer;
total, precio_udad : real;
begin
precio_udad := 198;
num_udes := 4;
total := num_udes * precio_udad;

write ('El precio sin IVA de',num_udes:3,' unidades es');

writeln(total:8:0,' pesetas');
writeln;
writeln; (* separamos 2 lineas *)

total := total + total * iva_factor;

write ('El precio con IVA de',num_udes:3,' unidades es');

writeln(total:8:2,' pesetas')
 end.

Salida del programa:

El precio sin iva de 4 unidades es 792 pesetas

El precio con iva de 4 unidades es 918.72 pesetas

A que adivino cuál es la pregunta del millón para ti en este momento...

¿Cuál es la diferencia entre write y writeln?

Es algo muy sencillo que casi suena a tontería. Se trata de que el
procedimiento writeln pasa el cursor a la siguiente línea después de escribir
los ítems, mientras que write lo deja después del último carácter. Si quieres,
puedes ir a un ejemplo que te puede ayudar a comprenderlo.

Volver al inicio de la página

Pasar al siguiente apartado sobre los formatos de salida

Formatos en la salida de datos

En una llamada a uno de los procedimientos write, además de incluír ítems,
también podemos especificar de qué manera se mostrarán en la pantalla
estos ítems. Son los llamados formatos de salida.

Estos formatos no son gran cosa, pero te permitiran jugar un poco con la
apariencia que presentarán tus datos. Podrás especificar el número de
posiciones para el campo de escritura. Y para los valores reales, el número de
decimales a mostrar.

La sintaxis de ambos formatos se muestra a continuación. Aunque lo mejor para

comprender esto es que vayas al ejemplo, pues allí podrás modificar los
parámetros de los formatos y ver cómo cambia la salida.

writeln(ítem: anchura ...)

writeln(ítem_real: anchura: dígitos ...)
anchura: valor entero que indica la anchura total del campo de
escritura digitos: valor entero que indica el número de decimales a mostrar

Volver al inicio de la página

Pasar al siguiente ejemplo sobre write y writeln

Veamos un ejemplo de salida de datos

A continuación tienes un ejemplo con el que puedes interactuar. Con él se
pretende que comprendas mejor las semejanzas y diferencias de los
procedimientos write y writeln.

El ejemplo simula el cuerpo principal de un programa Pascal en el que hay dos

instrucciones de salida de datos. En ellas se trata con una variable (Palabra) y una
constante (Pi). En ambas instrucciones puedes variar los formatos de salida a tu
gusto. También puedes elegir entre write o writeln. Los distintos resultados que se
producirían al variar todos estos parámetros aparecen en la parte inferior.

Volver al inicio de la página

Pasar al siguiente punto sobre read y readln

Los procedimientos de entrada de datos: read y readln

En este apartado trataremos la entrada de datos, también conocida como lectura
de datos. En Pascal existen dos procedimientos que nos permiten leer datos de la
entrada estándar (el teclado) son read y readln.

A continuación puedes echarle un vistazo a la sintaxis de estos procedimientos:

read (variable1, variable2, ...);

readln (variable1,variable2, ...);

A diferencia de los procedimientos write, con read y readln sólo puedes

usar variables como parámetros. Esto es lógico ya que las variables pueden
cambiar su valor en el cuerpo del programa. Los tipos de datospermitidos para
estas variables son: enteros, reales, caracteres o cadenas de caracteres.

¿Cómo funcionan read y readln?

 Ambos procedimientos esperan a que pulses la tecla INTRO antes de asignar

valores a variables
 Si intentas leer más de una variable en una llamada, tendrás que teclearlas
en el orden en el que aparecen en el procedimiento
 Además, si no quieres tener problemas, lo mejor será que dejes uno o más
espacios entre los datos que teclees.
 La principal diferencia entre ambas es que después de leer los
datos, read deja el cursor a continuación del último carácter, mientras
que readln lo pasa al comienzo de la siguiente línea.

En el siguiente ejemplo se utilizan varias llamadas a read y readln. Es un ejemplo

típico de entrada/salida. En el, se solicitan datos al usuario, y este tiene que
introducirlos por teclado. A continuación del código tienes una de las posibles
entradas correctas.

program Datos_Personales;
var
Nombre : string[15];
Ap1, Ap2 : string[20];
Edad : integer;

begin
write('Introduce nombre: ');
readln(Nombre);
write('Primer apellido : ');
readln(Ap1);
write('Segundo apellido: ');
readln(Ap2);
write('Introduce edad : ');
readln(Edad);
end.

Una posible entrada correcta

Introduce nombre: Benito
Primer apellido : Santos
Segundo apellido: Feijoo
Introduce edad : 21
9.- ESTRUCTURAS DE CONTROL SELECTIVAS. LA SENTENCIA IF. FORMATO DE LA SENTENCIA
IF- THEN- ELSE. EJEMPLOS

La estructura condicional if ... else[editar]

En la gran mayoría de los programas será necesario tomar decisiones sobre qué acciones
realizar. Esas decisiones pueden depender de los datos que introduzca el usuario, de si se ha
producido algún error o de cualquier otra cosa.

La estructura condicional if ... else es la que nos permite tomar ese tipo de decisiones.
Traducida literalmente del inglés, se la podría llamar la estructura "si...si no", es decir, "si se
cumple la condición, haz esto, y sino, haz esto otro".

Un ejemplo sencillo sería el siguiente (no se trata de un programa completo, sino tan sólo
una porción de código):

if (edad < 18)

printf("No puedes acceder.\n");

else

printf("Bienvenido.\n");

Este código de ejemplo dice que si el valor de la variable edad es menor que 18 se
imprimirá "No puedes acceder.\n", mientras que en caso contrario se
imprimirá "Bienvenido.\n".

Como se ve en el ejemplo, la estructura de un condicional es bastante simple:

if (condición) {

sentencias_si_verdadero;

} else {

sentencias_si_falso;

La condición, encerrada entre paréntesis, es una expresión que puede dar como
resultado 0 (interpretado como falso) o cualquier valor distinto de 0 (interpretado
como verdadero). Cuando la condición sea verdadera, se ejecutarán las sentencias dentro
del primer bloque de código, cuando la condición sea falsa, se ejecutarán las sentencias del
segundo bloque de código. Las expresiones y valores de tipo verdadero/falso son también
llamados valores lógicos o booleanos.

La indentación o sangría (los espacios al comienzo de las líneas) no es necesaria, pero ayuda
a la claridad del código. La utilización de las llaves {...} es obligatoria cuando se quiere utilizar
más de una instrucción por bloque, y optativa cuando sólo se quiere escribir una instrucción.
Por claridad, sin embargo, es recomendable utilizarlas aún cuando sólo vaya a haber una
instrucción.

El bloque del else es opcional. Si no se lo encuentra, sólo se realizará la acción

correspondiente al bloque if.

A continuación, un ejemplo con una función, que devuelve el mayor de dos números:

int mayor(int a, int b)

if (b > a) {

return b;

}// No posee especificación de la parte "else", ya que no es necesaria.

return a; // Finaliza la función retornando el valor de "a".

Operadores de comparación[editar]

El símbolo > visto en el último ejemplo es un operador, que en este caso compara dos
números enteros y devuelve verdadero si el primero es mayor, falso en caso contrario.

A continuación un listado de los posibles operadores de comparación en C y su significado.

Operadores de Comparación
Operador Significado
< estrictamente menor que
> estrictamente mayor que
<= menor o igual que
>= mayor o igual que
== igual a
!= distinto de
Teniendo en cuenta que en C se toma como falso el valor 0, y como verdadero cualquier otro
valor, una práctica común es expresar condiciones sin utilizar ningún operador:

float division(int dividendo, int divisor)

if (divisor) {

return dividendo / divisor;

} else {

printf ("No se puede dividir por cero\n");

return 0;

En este caso, la expresión (divisor) es equivalente a (divisor != 0).

Operadores lógicos[editar]

Los operadores && ("y"), || ("o") y ! ("no") son operadores lógicos. Permiten operar con
expresiones lógicas para generar expresiones más complejas.

Por ejemplo: determinar si un año es bisiesto o no. Los años son bisiestos si son divisibles por
4, pero no si son divisibles por 100, a menos que también sean divisibles por 400.

if ( (!(a % 4) && (a % 100)) || !(a % 400) ) {

printf("es un año bisiesto.\n");

} else {

printf("no es un año bisiesto.\n");

En realidad, teniendo en cuenta la prioridad de los operadores utilizados, podemos

simplificar la expresión anterior del siguiente modo:
 if ( !(a % 4) && (a % 100) || !(a % 400) ) {

printf("es un año bisiesto.\n");

} else {

printf("no es un año bisiesto.\n");

Además, como a cada rama del if le sigue una única instrucción, podemos expresar la
expresión anterior del siguiente modo:

if ( !(a % 4) && (a % 100) || !(a % 400) )

printf("es un año bisiesto.\n");

else

printf("no es un año bisiesto.\n");

En este caso, se utiliza el operador módulo (%), que obtiene el resto de la división entera de
un número por otro. Cuando un número es divisible por otro, el resto de su división entera
será cero. Siendo que cero es equivalente a falso, y cualquier valor distinto de cero es
equivalente a verdadero, podemos usar el operador % para verificar si el número es múltiplo
de 4, de 100 o de 400.

Evaluación de cortocircuito[editar]

La evaluación en corto circuito es una característica del lenguaje C que se utiliza para
optimizar la ejecución de programas. Consiste en que el programa puede verificar si una
expresión es verdadera o falsa antes de haber evaluado toda condición.

Por ejemplo, si se tiene una condición como la siguiente:

if ((a > 2) || (b < 4)) {

...

}
Al ejecutarse el programa, se evaluará primero si a > 2. En el caso en que sea verdadero, no
continuará con la siguiente condición, ya que el resultado será de cualquier modo verdadero.

De la misma forma, si la condición fuera:

if ((a > 2) && (b < 4)) {

...

En este caso, si no se cumple que a > 2, no se evaluará la siguiente condición, ya que el

resultado será falso de todos modos.

Esta característica no tiene demasiada importancia al comenzar a programar, pero facilitará

ciertas operaciones y optimizaciones en programas avanzados.

La estructura condicional abierta y cerrada switch ... case[editar]

La estructura condicional switch ... case se utiliza cuando queremos evitarnos las llamadas
escaleras de decisiones. La estructura if nos puede proporcionar, únicamente, dos
resultados, uno para verdadero y otro para falso. Una estructura switch ... case, por su parte,
nos permite elegir entre muchas opciones. Ejemplo:

#include <stdio.h>

#include <stdlib.h>

int main(void) {

int dia;

printf("¿Qué número de día de la semana es?");

scanf("%i",&dia);

switch(dia) {
case 1 :

printf("Lun, Lunes");

break;

case 2 :

printf("Mar, Martes");

break;

case 3 :

printf("Mier, Miercoles");

break;

case 4 :

printf("Jue, Jueves");

break;

case 5 :

printf("Vie, Viernes");

break;

case 6 :

printf("Sab, Sabado");

break;

case 7 :

printf("Dom, Domingo");

break;

default :

printf("No existe");
}

return 0;

La estructura anterior, de realizarse con sentencias if, necesitaría cuatro de ellas, resultando
un enorme bloque muy difícil de leer. En la mayoría de los casos, además, la
sentencia switch proporciona una ganancia en velocidad del código, pues permite al
compilador trabajar en base a que se trata de una decisión múltiple para una única variable,
cosa que con sentencias if el compilador no tiene por qué detectar.

Como vemos, para cada valor de la variable se ejecuta un bloque de sentencias distinto, en el
que no necesitamos llaves. Hay un caso especial, default, que se ejecuta si ningún otro
corresponde, y que no es necesario poner. Es, en todo, equivalente al bloque else de una
sentencia if.

Las sentencias break son muy importantes, ya que el comportamiento normal de un

bloque switch es ejecutarlo todo desde la etiqueta case que corresponda hasta el final. Por
ello, si no queremos que se nos ejecute más de un bloque, pondremos sentencias break al
final de cada bloque excepto el último.

Es decir, las etiquetas case son puntos de entrada de la ejecución, y no implican que al
acabarse el bloque case la ejecución salte al final del bloque switch. Las
etiquetas case siguientes a la que hemos utilizado para entrar son, sencillamente, ignoradas.

A la ausencia de sentencias break se le llama, en ocasiones, "dejar caer la cascada switch".

El bucle while[editar]

El bucle while sirve para ejecutar código reiteradas veces.

while (/*condicion*/) {

/* Código */

La condición debe de ser una expresión lógica, similar a la de la sentencia if. Primero se
evalúa la condición. Si el resultado es verdadero, se ejecuta el bloque de código. Luego se
vuelve a evaluar la condición, y en caso de dar verdadero se vuelve a ejecutar el bloque. El
bucle se corta cuando la condición da falso.

Ejemplo: imprimir los números de 0 a 99:

int i = 0;

while (i < 100) {

printf("%d\n", i);

i = i + 1;

Inicialmente se declara que la variable i tiene un valor de 0. Al iniciar el bucle, se cumple la

condición i < 100, por lo que se procede a la instrucción de imprimir dicho número (cero, en
el caso inicial). Posteriormente i cambiará su valor de uno en uno por la instrucción i = i + 1 y
seguidamente dicho valor nuevo, será evaluado en la condicion whilehasta que i llegue al
valor 100, donde debido a la condicional, éste será un valor falso, dando fin al código.

El bucle for[editar]

El bucle for es un bucle muy flexible y a la vez muy potente ya que tiene varias formas
interesantes de implementarlo, su forma más tradicional es la siguiente:

for (/* inicialización */; /* condición */; /* incremento */) {

/* código a ejecutar */

Inicialización: en esta parte se inicia la variable que controla el bucle y es la primera sentencia
que ejecuta el bucle. Sólo se ejecuta una vez ya que solo se necesita al principio del bucle.

Expresión condicional: al igual que en el bucle while, esta expresión determina si el bucle
continuará ejecutándose o no.

Incremento: es una sentencia que ejecuta al final de cada iteración del bucle. Por lo general,
se utiliza para incrementar la variable con que se inicio el ciclo. Luego de ejecutar el
incremento, el bucle revisa nuevamente la condición, si es verdadera tiene lugar una
ejecución más del cuerpo del ciclo, si es falsa se termina el ciclo y así.

Aquí se muestra el mismo ejemplo visto para el bucle while, pero implementado con un
bucle for:

int i;

for (i=0; i < 100; i = i + 1) {

 printf("%d\n", i);

Nota: En C, la sentencia i = i + 1 puede escribirse en forma más reducida como i++. Esta forma
se utiliza más comúnmente en el bucle for:

int i;

for (i=0; i < 100; i++) {

printf("%d\n", i);

El bucle do...while[editar]

El bucle do...while es un bucle que, por lo menos, se ejecuta una vez. Do significa
literalmente "hacer", y while significa "mientras".

Su forma es esta:

do {

/* CODIGO */

} while (/* Condición de ejecución del bucle */)

Os muestro un ejemplo sencillo de uso:

int aleatorio;

do {

aleatorio = rand();

} while (aleatorio != 25);

La verdad es que este ejemplo puede resultar un poco absurdo, pero es bastante intuitivo. El
código del bucle asigna un valor aleatorio a la variable definida anteriormente, y mientras esa
variable no tenga el valor 25, el bucle sigue ejecutándose.

La sentencia goto[editar]
La sentencia goto sirve para indicar al programa que continue ejecutándose desde la línea de
código indicada. Su sintaxis es más o menos así:

/* Código */

ETIQUETA:

/* Código */

goto ETIQUETA;

/* Código */

10.- ESTRUCTURAS DE CONTROL REPETITIVAS . CICLOS. LA SENTENCIA WHILE, SU FORMATO.

EJEMPLOS. LAS INTRUCCIONES FOR Y REPEAT.

ESTRUCTURAS DE CONTROL REPETITIVAS O ITERATIVAS

Esta vez vamos a ver cómo se utiliza las estructuras de control repetitivas en Java (también
conocidas como ciclos o bucles). Como mencionaba en el tutorial Estructuras de control
condicionales vamos a necesitar de estas estructuras al momento de programar, y pues
bueno este tipo de estructuras de control se las utiliza cuando necesitamos recorrer un
conjunto de datos, por ejemplo al leer un archivo, al leer registros de una base de datos, en
fin, en todos los problemas en los que se tenga que hacer iteraciones, bucles, siempre vamos
a necesitar de estas estructuras.

LA ESTRUCTURA DE CONTROL FOR

El ciclo for permite ejecutar un conjunto de sentencias un número fijo de veces y antes de
saber cómo funciona esta sentencia, primero que nada vamos a ver la sintaxis.

Nota importante: Este ciclo se lo utiliza cuando sabemos el número de veces que se debe
ejecutar el ciclo.
1 for(variable_inicializacion;condicion;incremento)

2{

3 //instrucciones

4}

VAMOS A VER COMO FUNCIONA

Como podemos ver esta sentencia esta compuesta de 3 partes separadas por ; (punto y
coma) la primera parte llamada inicialización permite controlar el ciclo, suele ser la variable
de tipo entero por lo general la letra i, pero puede ser cualquier otra letra, esta variable es
declarada e inicializada dentro de la estructura aunque se la puede hacer desde fuera, la
variable de inicialización indica desde que valor va empezar el ciclo.

La segunda parte es la condición, la condición indica cuantas veces se va ejecutar el ciclo y se

evalúa antes de cada iteración, si la condición es verdadera el ciclo continua, tomar en
cuenta que si se omite esta parte, el ciclo se vuelve infinito.

La tercera parte es el incremento o decremento y le indica en pasos de cuanto debe

incrementarse o decrementarse la variable de inicialización en cada iteración, por lo general
es de uno en uno, pero todo dependerá del problema que se quiera resolver, también puede
omitirse esta parte, si se lo hace el ciclo se vuelve infinito (no siempre).

AHORA UN EJEMPLO

1. Imprimir por consola los números enteros desde el 2 hasta 20

Este es un problema sencillo que se lo puede resolver utilizando el ciclo for:

1 package com.ecodeup.ciclos;

3 public class TestCiclos {

4 public static void main(String[] args) {

5 for (int i = 2; i < 21; i += 2) {

6 System.out.println("Número: " + i);

7 }

8 }

9}

PROCESO

1. La variable i es declarada en inicializada en 2 (también se la puede declarar en

inicializar fuera y omitir esa parte).
2. Seguido de esto el compilador verifica si la variable i es menor a 21, si es correcto
continúa el ciclo, ejecuta la (s) instrucciones y luego.
3. La variable i se incrementa en 2.

El compilador repite las mismas instrucciones desde el paso 2 hasta que i toma el valor de 22,
la condición se verifica y como no se cumple, el ciclo termina.

El ciclo for puede tomar varias sintaxis sin que esto genere errores de compilación o cambie
el resultado del programa. A continuación se muestra algunas sintaxis con las que nos
podemos encontrar.

Ahora el mismo ejemplo anterior lo adaptamos a esta sintaxis, como se puede ver la variable
de incremento se omite y se la pone dentro del ciclo, luego de las instrucciones.

1 package com.ecodeup.ciclos;

3 public class TestCiclos {

4 public static void main(String[] args) {

5 for (int i = 2; i < 21;) {

6 System.out.println("Número: " + i);

7 i += 2;

8 }

9 }

10 }

Nota: En este caso la variable i es visible sólo dentro del ciclo for, puesto que se la ha
declarado e inicializado dentro del ciclo, si la quisiéramos utilizar fuera, nos va lanzar un
error.

En algunos casos también se presenta con la siguiente sintaxis, en este caso la variable de
inicio esta fuera del ciclo y la variable de incremento está después de las instrucciones a
ejecutar.

1 package com.ecodeup.ciclos;

3 public class TestCiclos {

4 public static void main(String[] args) {

5 int i = 2;

6 for (; i < 21;) {

7 System.out.println("Número: " + i);

8 i += 2;

9 }

10 }

11 }
En este caso la variable i es visible para todo el programa puesto que la hemos declarado
fuera del ciclo.

LA ESTRUCTURA DE CONTROL WHILE

Esta estructura es parecida al ciclo for, la diferencia está en su sintaxis:

1 while (condicion) {

2 //instrucciones

3}

El ciclo while permite ejecutar n veces un conjunto de instrucciones siempre y cuando la

condición se cumpla o sea verdadera.

Nota importante: Este ciclo se utiliza cuando no sabemos el número de veces exacto que se
ejecutará el ciclo.

Si la condición siempre es verdadera o siempre se cumple este ciclo puede crear un bucle
que nunca termine, por eso hay que tener en cuenta que en algún momento del ciclo la
condición no debe cumplirse (debe volverse falsa) para que el ciclo termine, caso contrario el
ciclo se vuelve infinito.

VAMOS A VER UN EJEMPLO

1. Ingresar un número por teclado e imprimir por la consola su decena superior: Ejemplo
sin ingreso el número 5, su decena superior es 10, si ingreso el 25, su decena superior
es 30.

ANÁLISIS DEL PROBLEMA PARA SABER QUE CICLO UTILIZAR

El ejemplo anterior lo podemos resolver también con un ciclo for, pero como no sabemos
cuantas iteraciones o cuantas veces se repite el ciclo ya que la decena superior cambiará de
acuerdo al número ingresado, es recomendable utilizar el ciclo while.

A continuación el código.
1 package com.ecodeup.ciclos;

3 import java.util.Scanner;

5 public class TestCiclos {

6 public static void main(String[] args) {

7 int numero;

8 Scanner entrada = new Scanner(System.in);

9 System.out.println("Ingrese un número:");

10

11 try {

12 numero = entrada.nextInt();

13 while ((numero % 10) != 0) {

14 numero++;

15 }

16 System.out.println("La decena superior es: " + numero);

17 } catch (Exception e) {

18 System.out.println("Número no válido");

19 }

20 }
21 }

Explicando un poco el ciclo, en la línea 12, se obtiene el número desde teclado (si deseas un
ejemplo completo de cómo ingresar números desde teclado puedes ingresar a esta
entradaEntrada de datos en Java utilizando la Clase Scanner), en la línea 13 empieza el ciclo
while, la condición para que ingrese al ciclo, es que el módulo o resto de dividir el número
entre 10 sea diferente de cero.

El módulo de dividir cualquier número entre 10, (excepto los múltiplos de 10 por ejemplo 10,
20, 30, 40, etc..) siempre nos dará un valor diferente de cero y por ende ingresa al ciclo.

Entonces la idea es ir incrementando el número ingresado hasta que sea múltiplo de 10 y con
esto el módulo de dividir el número entre 10 va ser cero y por ende ya no va ingresar al
bucle.

Con esto el número se habrá incrementado y sabremos cual es la decena superior de

cualquier número ingresado.

LA ESTRUCTURA DE CONTROL DO WHILE

El ciclo do while también permite ejecutar n número de veces un conjunto de instrucciones,

es muy parecida a las otras 2 estructuras de control que hemos visto anteriormente, salvo
que este ciclo siempre se ejecuta por lo menos una vez, recordemos que en el ciclo for
debemos conocer el número de veces que se va ejecutar las instrucciones, el ciclo while hay
una condición que se debe cumplir para que se ejecuten las instrucciones, en cambio en
el ciclo do while primero se ejecutan las instrucciones y luego verifica la condición y si esta
es verdadera el ciclo se repite hasta verificar de nuevo la condición, para salir del ciclo la
condición se debe volver falsa.

La sintaxis del ciclo do while es la siguiente:

1 do {

2 //instrucciones

3 } while (condicion);

VAMOS A VER UN EJEMPLO

 1. Obtener los dígitos de un número ingresado por teclado, ejemplo 100, tiene 3 dígitos.

Una forma para obtener los dígitos que tiene un número, realizamos divisiones sucesivas
entre 10 hasta que el número se vuelve cero (del resultado de la división sólo se debe tomar
la parte entera), para obtener el número de dígitos contamos las veces que se ha dividido.
Por ejemplo tenemos el número 345:

El resultado debe ser almacenado en una variable de tipo entero.

345/10=34

34/10=3

3/10=0

En este caso se ha realizado 3 divisiones por lo que el número de dígitos es 3.

1 package www.ecodeup.com;

3 public class TestCiclos {

5 public static void main(String[] args) {

6 int numero = 345;

7 int contador = 0;

8 do {

9 numero /= 10;

10 System.out.println(numero);

11 contador++;
12 } while (numero != 0);

13 System.out.println("El número tiene " + contador + " dígitos");

14 }

15 }

También hubiésemos podido utilizar el ciclo while que funciona con todos los números,
menos con el número 0 (cero), no entra en el ciclo porque número es igual que cero y por
ende la respuesta va ser:

1 "El número tiene 0 dígitos"

Esto se soluciona con el ciclo do while que me garantiza que por lo menos el ciclo se va
ejecutar una vez, con esto, si se ingresa el número cero va ingresar al ciclo ya que la
condición se verifica al final.

11.- EL ENTORNO DE PROGRAMACION TURBO PASCAL. INSTALACION. ARRANQUE (CARGA) Y

SALIDA DEL TURBO PASCAL. ENTRONO DE PROGRAMACION TURBO PASCAL. LOS MENU.

El menú principal se activa pulsando la tecla F10 o al arrancar turbo pascal. Las opciones del
menú principal se pueden invocar pulsando simultáneamente la tecla ALT.Las diversas
opciones de un menú se pueden clasificar en cuatro categorías según su efecto.

1.-exit,sale del entorno turbo.

2.-file, conduce un submenú y un menú secundario.

3.-opciones que proponen (cl) cíclicamente valores o estados diferentes.

4.-opciones que solicitan información al usuario.

Algunos ejemplos de la barra de recordatorio de órdenes: F1-help, F6 –Switch, F5 –zoom, F7

–trace, F8 –Step, F9 –Make, F10 –Menú.

La secuencia de teclas hotkeys ejecutan ciertas funciones:

Alt-c.-Activa el menú compile

Alt-f.-Activa el menú file

Alt-E.-Activa el menú edit.

El turbo pascal proporciona al usuario ayuda en la pantalla para facilitar el aprendizaje

y el recordatorio de aspectos importantes de la gramática, sintaxis, y en general el entorno
turbo pascal.La secuencia de teclas que facilitan la consulta de las pantalla de ayuda
son: Alt+4, Alt+F10, CtrL+F1, Shift+F1.

12.- CREACION DE PROGRAMAS EN TURBO PASCAL. EDICION (ESCRIBIR UN PROGRAMA).

GUARDAR (GRABACION DEL PROGRAMA EN DISCO ). COMPILACION Y CORRECCION DE
ERRORES . EJECUCION (RUN). INDIQUE PASO A PASO LAS VENTANAS USADAS EN LOS
PROCESOS ANTERIORES (EDICION, GUARDAR, COMPILACION, Y CORRECCION DE ERRORES)