Programando desde 0: 10- Repetición condicional con REPEAT...UNTIL

Vlady_18 · 17/01/2012

LECCIÓN 10: Repetición condicional con REPEAT...UNTIL

La sentencia REPEAT funciona igual que WHILE y sirve para lo mismo, entonces ¿cuál es la diferencia? Escencialmente WHILE repite algo mientras una condición es verdadera, en contraparte REPEAT lo hace hasta que la condición sea verdadera, o sea, mientras la condición es falsa.

¿Qué ventaja tiene esto? Uno tiende a preguntarse a veces para qué sirve REPEAT ya que, si se repite mientras una condición es falsa podríamos simplemente utilizar WHILE con el operador NOT en su condición y listo. Sin embargo esto no es tan sencillo.

Otra diferencia es que WHILE verifica su condición antes de entrar en su bloque de instrucciones, REPEAT lo hace al final. ¿Qué significa esto? Veamos un código simple hecho con WHILE:

Este programa hará aumentar una variable desde 0 hasta 10 mostrando su valor en pantalla y terminará cuando eso suceda:

Código:

PROGRAM WhileVSRpeat;

VAR
    i: INTEGER;

BEGIN
    i:= 0; //Inicializamos la variable en 0.

    WHILE i<10 DO
    Begin
        i:= i+1; //Aumentamos el valor de i en 1.
        Write(i,' '); //Imprimimos el valor de i y un espacio de separación.
    End;         

    ReadLn;
END.

Como podrán observar este es un programa bien sencillo. Mientras i sea menor que 10 se repetirá el bloque dentro del WHILE. Cuando i valga 10 el WHILE verificará eso y pues no entrará en su bloque y la iteración terminará.

Ahora veamos exactamente el mismo programa en su versión con REPEAT. Esto servirá también para ver la sintaxis de esta nueva sentencia:

Código:

PROGRAM WhileVSRpeat2;

VAR
    i: INTEGER;

BEGIN
    i:= 0; //Inicializamos la variable en 0.

    REPEAT
        i:= i+1; //Aumentamos el valor de i en 1.
        Write(i,' '); //Imprimimos el valor de i y un espacio de separación.
    UNTIL i=10;;         

    ReadLn;
END.

Este programa hace exactamente lo mismo, solo que ahora en vez de repetirse mientras i<10, se repite hasta que i=10. Como ven, la condición del WHILE es opuesta a la de REPEAT y viceversa.

Dado este ejemplo pueden observar que si hay que repetir más de una instrucción (en este caso eran solo dos), en un WHILE hay que utilizar BEGIN y END para delimitar su bloque, pero REPEAT no lleva esta delimitación ya que se limita por sí mismo entre REPEAT y UNTIL. De este modo, mientras la sintaxis genérica de un WHILE es

Código:

WHILE condicion_es_verdadera DO
Begin
    Instrucción1;
    Instrucción2;
    . . .
    InstrucciónN;
End;

la de un REPEAT es

Código:

REPEAT
    Instrucción1;
    Instrucción2;
    . . .
    InstrucciónN;
UNTIL condicion_sea_falsa;

Con WHILE... DO queríamos decir "Mientras... Haz", con REPEAT... UNTIL estamos diciendo "Repite... Hasta que".

-----

Como ya dije, WHILE verifica su condición antes de entrar en su bloque de instrucciones, por lo tanto podría suceder que a la primera la condición fuera FALSE con lo cual WHILE no entraría nunca en su código y no se ejecutaría nunca. REPEAT verifica su condición al final, por lo tanto, sabemos siempre que esta sentencia se ejecutará al menos una vez, ya que entrará en su código, hará lo que tenga que hacer, y luego mirará la condición.

Esto es lo que nos marca la diferencia esencial entre una sentencia y la otra. La gente tiende a preguntarse cuándo usar REPEAT y cuando usar WHILE. Pues bien, la respuesta es:

Cuando sé que una lista de instrucciones debe ejecutarse al menos una vez como mínimo, entonces uso REPEAT. Si sabemos que es admisible que la lista de instrucciones pueda NO ejecutarse nunca, entonces usamos WHILE.

¿Es correcto o incorrecto no discriminar estos casos? Pues si el programa hace lo que tiene que hacer, podríamos decir que cada uno puede usar la sentencia con la que mejor se lleve, sin embargo, hacerlo como he descrito ayuda a una mayor legibilidad del código fuente ya que al ver un REPEAT sabemos que lo que sea que este haga debe hacerse al menos una vez.

Ejemplo: Veamos un programa en el que se le pedirá al usuario ingresar un número entero. Si este número es menor que 20, iteraremos hasta dejarlo en 20, mostrando siempre los números en pantalla:

Versión WHILE:

Código:

PROGRAM WhileVSRepeat3;

VAR
   num: INTEGER;

BEGIN
    Write('Ingresa un número entero: ');
    ReadLn(num);

    WHILE num<20 DO
    Begin
        num:= num + 1;
        Write(num,' ');
    End;

    ReadLn;
END.

Como ven, en este programa, si el usuario ingresa de entrada un número mayor o igual que 20 el WHILE no se ejecutará en absoluto, en caso contrario sí lo hará y se repetirá tantas veces como sea necesario.

Versión REPEAT:

Código:

PROGRAM WhileVSRepeat4;

VAR
   num: INTEGER;

BEGIN
    Write('Ingresa un número entero: ');
    ReadLn(num);

    REPEAT
        num:= num + 1;
        Write(num,' ');
    UNTIL num>=20;

    ReadLn;
END.

¿Cuál es la diferencia entre este programa y el anterior? Pues si en el anterior programa el usuario ingresaba el número 20 el WHILE no se ejecutaba y la variable no aumentaba su valor. En este programa, aunque REPEAT se repetirá hasta que la variable valga 20, si el usuario ingresa justo ese número el bloque del REPEAT se ejecutará igual porque esta sentencia verificará el valor de num justo al final de su bloque. Incluso se ejecutará aunque el usuario ingrese un número más alto que 20 ¿comprenden?

-----

Para el programa del Adivinador que les fue solicitado en la Lección 8 ¿Qué conviene más utilizar? ¿WHILE o REPEAT?

Yo les diría que REPEAT, porque saben que el usuario intentará adivinar al menos una vez pudiendo adivinar o no. Si adivina, pues genial, si no adivina se seguirá repitiendo.

Con WHILE ustedes estarán obligados a hacer que las condiciones sean falsas para que entre en el bloque al menos una vez.
-------------------------------------------------------------------------------------

Centinela:

Veremos ahora, aunque sin usar REPEAT un ejemplo de iteración por centinela. Un centinela es un valor que tomará nuestra variable para indicar el fin de la iteración, algo así como una bandera booleana, pero aplicado a otras variables. Veámoslo para comprenderlo mejor. El siguiente programa irá leyendo de la entrada estándar una serie de números enteros positivos y realizando su suma hasta que se ingrese un negativo. En ese caso ya no se leerán más números y luego se mostrará la suma de todos los números ingresados (excepto el negativo):

Código:

1   PROGRAM centinela;
2
3   Var
4      numero, suma : integer;
5
6   BEGIN
7   (* lectura inicial *)
8   ReadLn(numero);
9
10 (* inicialización *)
11 suma:= 0;
12
13 WHILE numero > 0 DO
14 Begin
15     (* acumulación *)
16     suma:= suma + numero;
17     (* siguiente lectura *)
18     ReadLn(numero);
19 End;
20
21 (* mostrar resultado *)
22 WriteLn('La suma de los números es: ', suma);
23 END.

Bien, en la línea 8 leemos el primer valor que debemos sumar. En la línea 10 inicializamos la variable suma con el valor 0 ya que aún no ha sumado nada.
En la línea 13 comienza el WHILE solo si el número que ingresamos es mayor que 0, en caso contrario no se ejecutará. Aquí vemos por qué es mejor utilizar un WHILE que un REPEAT, ya que si el usuario ingresa como primer valor un número negativo ya no habrá nada para sumar.
En caso de entrar en el WHILE aumentamos el valor de la variable suma sumando su valor anterior al valor del número leído, o sea, al valor de numero. En la línea 18 volvemos a leer un número y el WHILE volverá a su encabezado. Si el nuevo número leído es menor que 0 ya no habrá iteración y en caso contrario sí.
Luego de haber salido del WHILE mostramos al usuario el resultado de la suma.

Bien, esto era para mostrar la idea de centinela. En este caso nuestro centinela es cualquier número negativo ingresado por el usuario ya que éste será el que detenga la iteración del WHILE. Veremos muchos más ejemplos de centinelas de aquí en adelante.

Ejercicio: Si han hecho el programa del Adivinador con WHILE, ahora háganlo con REPEAT.

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

Un ejemplo más complejo: Contador de palabras:

Ahora veremos un ejemplo de programa que cuente la cantidad de palabras en una línea de texto que será ingresada por el usuario. Dicho texto debe terminar con un espacio y un punto sí o sí (centinelas).

¿Cómo funcionará el programa? Leeremos todo caracter a caracter, nada de usar Strings. Consideraremos palabra todo aquello que no es un espacio, por lo tanto, letras sueltas también son palabras.

Como en primera instancia el usuario puede escribir un texto que comience con espacios en blanco, usaremos un REPEAT para ir leyendo todos esos espacios hasta encontrar otra cosa.

Luego de eso entraremos en un bucle principal dominado por un WHILE, esto es porque nuestro centinela es el punto (.) y puede suceder que el usuario ingrese un punto como inicio del texto o un punto luego de los espacios iniciales; en cualquiera de esos casos WHILE no entrará en su código.

Mientras no encontremos ese punto (.), leeremos los caracteres hasta hallar un nuevo espacio con lo cual habremos consumido una palabra, luego volvemos a usar, dentro de WHILE esta vez, un REPEAT para consumir espacios en blanco ya que entre una palabra y otra el usuario puede poner varios espacios consecutivos:

Código:

1   PROGRAM cuenta_palabras;
2
3   Const
4      ESPACIO= ' ';
5      FIN= '.';
6
7   Var
8      caracter: char; //Caracter leído.
9      cantidadPalabras: integer;//Cantidad de palabras contadas.
10
11 BEGIN
12 //Salteamos todos los espacios al inicio del texto.
13 Repeat
14    read(caracter)
15 Until caracter <> ESPACIO;
16
17 //En cada iteración consumiremos una palabra.
18 While caracter <> FIN do
19 begin
20    //Leemos caracteres hasta encontrar un espacio.
21    Repeat
22       read(caracter);
23    Until caracter = ESPACIO;
24
25    //Aumentamos en 1 el contador.
26    cantidadPalabras:= cantidadPalabras + 1;
27
28    //Salteamos los espacios que separan las palabras.
29    Repeat
30       read(caracter)
31    Until caracter <> ESPACIO;
32 end; //Del While.
33
34
35 writeln('La cantidad de palabras en el texto es: ',cantidadPalabras);
36 END.

Les dejaré como tarea que estudien este código hasta que lo entiendan completamente. Fíjense como implementamos distintos REAPEAT dentro de un WHILE y como usamos el procedimiento READ para siempre ir leyendo sobre la misma línea. No olviden las constantes declaradas al inicio del programa. Los comentarios son su gran guía y eso es algo muy importante para un programador. Si deben trabajar con el código de su compañero de trabajo deberán ser capaces de entender sus códigos basados en que saben la tarea que desempeña su programa, las variables que declaro tienen nombres mnemotécnicos y sus comentarios indican bien cada acción aunque sin extenderse o abusar de ellos. Todo esto es realmente muy importante que aprendan a implementarlo.

Por si alguno de ustedes no lo sabe, un nombre mnemotécnico es aquel que ayuda a saber el propósito de una variable, por ejemplo, en este programa la variable que guarda el valor de cuantas palabras se cuentan se llama cantidadPalabras. Bien podía haberse llamado cont que es una abreviación de contador o podría haber tenido cualquier otro nombre. Usen nombres mnemotécnicos aunque sean largos, esto ayuda a prescindir un poco de los comentarios y a que el código sea más entendible.

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

Ejemplo de captura de error:

En el siguiente ejemplo veremos un programa simple que le pedirá al usuario que ingrese un valor entero. En esta ocasión veremos como leer estos valores como caracteres y luego si son correctos pasarlos a enteros tal como debería ser. Primero veamos algo que debería haber nombrado ya hace bastante pero sin embargo decidí aplazarlo hasta ahora.

En algunas partes de este curso nombré algo así como "el ordinal de un elemento" o "tipos ordinales" y dije que estos eran los tipos que tenían finita cantidad de elementos y que además, dado un elemento, podíamos saber cuál le seguía (sucesor) y cual estaba detrás (predecesor). Los tipos ordinales de Pascal son aquellos que están acotados, o sea, que tienen un inicio y un final. Tal es el caso del tipo INTEGER, que está acotado inferiormente por el valor -32768 y superiormente por MAXINT que vale 32767. Ninguna variable del tipo integer puede exceder estos valores. Si han activado el range checking tal como se los indiqué al inicio del curso deberían recibir un error en tiempo de compilación al intentar guardar en una variable entera algún valor fuera del intervalo [-32768, 32767], de lo contrario el error lo obtendrán en tiempo de ejecución.
Además de esto, el tipo dado un elemento del tipo INTEGER podemos saber quién está detrás y quién delante, por ejemplo, dado el número entero 5 sabemos que detrás está el 4 y delante el 6. Para el número -32768 no existe predecesor porque es el primer entero existente para pascal, al igual que para MAXINT, que no existe sucesor porque es el entero más grande que pascal puede representar.

Tenemos el tipo CHAR, que contiene todos los caracteres existentes. Obviamente este tipo es acotado ya que tiene una cantidad finita de elementos y además, dado un caracter podemos saber cuál es su predecesor y su sucesor.

El tipo REAL no es acotado ya que posee una cantidad infinita de elementos. Nunca se puede determinar el siguiente a un real. ¿Cuál número es el siguiente a 1.5? ¿Tal vez el 1.6? No porque antes está el 1.55, pero antes de ese está el 1.51, pero antes está el 1.501, y así podríamos continuar infinitamente. Siempre entre dos números reales cualesquiera hay infinitos reales. Esto en matemáticas es llamado densidad de los reales.

Lo importante aquí es hablar del ordinal de un carácter. Los caracteres están todos incluidos, para Free Pascal (existen otras tablas), en una tabla llamada Tabla Ascii. Esta tabla le asigna a cada carácter un valor numérico según su posición. Para ver la tabla Ascii en el IDE simplemente vayan al menú Tool --> Ascii table.

src="http://i30.servimg.com/u/f30/16/10/20/71/aprend29.jpg" border="0" alt=""

En esa imagen el cursor está posicionado sobre el símbolo @. Como vemos, a este carácter le corresponde el valor 64. Ese valor es el ordinal de @. Si nosotros tenemos un carácter cualquiera y queremos saber su ordinal debemos usar la función ORD. Por ejemplo si escribiéramos ORD(@) obtendríamos el entero 64 como resultado. A la inversa tenemos la función CHR que dado un entero nos devuelve su correspondiente carácter en la tabla. Si escribiéramos CHR(64) obtendríamos como valor devuelto el carácter @.
La función CHR dado un elemento del tipo Integer devuelve uno del tipo CHAR. La función ORD transforma un carácter en entero, o sea, de un tipo char obtenemos un tipo integer. Esto es lo que usaremos para, dado un carácter numérico, obtener el entero de ese carácter, o sea, dado el carácter ‘1’ obtener el número 1.

Sin embargo no es tan fácil, observen ustedes en la tabla que al carácter ‘0’ le corresponde el entero 48 ya que está en la posición 49 de la tabla (la primera posición es la 00). Al carácter ‘1’ le corresponde el entero 49 y así sucesivamente. Por lo tanto si nosotros leyéramos un carácter de la entrada estándar, suponiendo que el usuario ingresó el ‘1’, al hacer ORD(‘1’) obtendríamos el número 49 y no el número 1.

¿A alguno de ustedes se les ocurre como, dado un carácter numérico, obtener su valor en entero? O sea, si me dan el ‘2’ obtener el 2, si me dan el ‘8’ obtener el 8, y así. Como pueden observar, los lugares de la tabla están ordenados ascendentemente, por lo cual si al ‘0’ le corresponde el 48, al ‘1’ le corresponde el 49, al ‘2’ el 50 y así hasta el ‘9’ que le corresponde el 57. ¿Entonces que pasa si al ordinal de cualquier carácter numérico le resto el ordinal de ‘0’? Por ejemplo, si me dan el ‘0’, resto ese ordinal con el ordinal de ‘0’:

Ord(‘0’) - Ord(‘0’)= 48 – 48= 0. Obtuve el entero 0. Ahora si me dieran el carácter ‘1’ y a su ordinal le resto el ordinal de ‘0’:

Ord(‘1’) - Ord(‘0’)= 49 – 48= 1. Obtuve el entero 1. De tener el ‘9’ y restarle a su ordinal el ordinal de '0' tendría:

Ord(‘9’) - Ord(‘0’)= 57 – 48= 9. Obtuve el entero 9.

NOTA: El ordinal de un entero es el mismo entero: Ord(57)= 57.
El ordinal de un boolean es 1 para TRUE y 0 para FALSE.

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

Vayamos al ejemplo entonces. Le pediremos al usuario que ingrese un entero, pero lo leeremos como caracter, o sea, como un elemento del tipo CHAR. Si los caracteres leídos difieren de los numéricos le diremos al usuario que hay error, sino, transformaremos los caracteres a enteros. Para este programa usaremos la función EOLN que es TRUE cuando el cursor de la entrada estándar está en el fin de la línea y FALSE en caso contrario.

Esta función es primitiva de Pascal, o sea, la tenemos siempre disponible. Como pueden ver, es una función booleana ya que nos dará un valor TRUE o un valor FALSE.

Veamos el ejemplo:

Código:

1   PROGRAM enteros;
2
3   Var
4      car: char; //Caracter leído.
5      entero: integer; //Guardará el valor del caracter pero en INTEGER.
6      error: boolean; //TRUE si el usuario no ingresa un entero.
7
8
9   BEGIN
10 
11
12 //Mostramos un mensaje al usuario y leemos la entrada.
13 write('Ingrese un entero: ');
14 read(car);
15 //Damos la condición de error.
16 error:= (ord(car)<48) or (ord(car)>57);
17
18 If not error then
19    entero:= ord(car)-ord('0');
20
21 //Leemos hasta el fin de línea o hasta que haya error.
22 while (not eoln) and (not error) do
23 begin
24    //Leemos el siguiente caracter.
25    read(car);
26
27    //Verificamos que el caracter sea uno numérico.
28    error:= (ord(car)<48) or (ord(car)>57);
29
30    If not error then
31       entero:= (entero*10)+(ord(car)-ord('0'));
32 end;
33
34 If not error then
35    writeln('El entero ingresado es: ',entero)
36 else
37    writeln('No ha introducido un entero.');
38
39 END.

En este programa se pide un entero, pero el si el usuario ingresa cualquier otra cosa, el programa no caerá, sino que mostrará un mensaje de error.

Como primer ejercicio tienen que entender este programa y modificarlo para que funcione con REPEAT.

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

Ejercicios:

No continúen hasta no ser capaces de resolver todos estos ejercicios.

Ejercicio2: Determinen cuáles de los siguientes segmentos de código producen la misma salida al ser ejecutados:

a)

Código:

i := 1;
j := 2;
REPEAT
   Write(i, j);
   i := i + 1;
   j := j + 1
UNTIL j <= 3;

b)

Código:

i := 1;
j := 1;
WHILE (i <= 3) AND (j <= 2) DO
BEGIN
   Write(i, j + 1);
   i := i + 1;
   j := j + 1
END;

c)

Código:

i := 1;
REPEAT
   Write(i, i + 1);
   i := i + 1
UNTIL i <= 3;

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

Ejercicio3: Se desea tener un programa que calcule el saldo de una cuenta. Supongan que los datos son leídos de la entrada estándar y que constan de renglones, cada uno de los cuales contiene una letra en la primera columna, seguida de un valor real. El último renglón contiene únicamente la letra X en la columna uno. El primer renglón contiene la letra A y el saldo anterior de una cuenta de cheques. Los demás renglones contienen la letra D y el importe de un depósito o la letra R y el importe de un retiro. Escriban un programa que determine el saldo exacto de la cuenta después de procesar las transacciones. Asumimos que las entradas serán siempre correctas.

Ejemplo:

A 1200.35
D 64.12
R 390.00
R 289.67
D 13.02
R 51.07
X
El saldo final es 546.75

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

Ejercicio4: Dado un fragmento de texto que debe ser leído de la entrada estándar, todo en una línea, y terminado por el caracter $ (centinela), determine y exhiba las consonantes y vocales que aparecen duplicadas en forma contigua. Por ejemplo, el texto “llama al chico que lee$” tiene una consonante doble (ll) y una vocal doble (ee) y se debería desplegar: “ll ee”. (Todas las letras son minúsculas).

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

Ejercicio5: Realicen las funciones de una calculadora simple. Los datos de entrada serán una secuencia de dígitos enteros y los operadores +, *, / y -, seguida de un signo =. Hagan caso omiso de los espacios en blanco. Los operadores se aplican en el orden en que aparecen en los datos de entrada, o sea que olvídense de la precedencia, y producen resultados enteros, o sea, si bien se ingresa el operador de la división con el símbolo /, el comportamiento es el de DIV. Asuman que se ingresa al menos un número.

Ej. de entrada: 4 + 3 / 2 * 8 - 4 =
Ej. de salida: 20

Como ven, las operaciones se fueron realizando en el orden en el que aparecían. Primero 4+3 que es 7, eso lo dividimos entre 2 (div) que es 3, luego eso multiplicado por 8 que es 24 y luego eso menos 4 que es 20. Una verdadera calculadora habría hecho primero 3/2 que con DIV da 1 y luego eso por 8 que da 8. Luego haría 4+8-4 que es igual a 8. Sin embargo programar eso requiere más herramientas de las que poseen.

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

Ejercicio6 (DIFICIL): Escriban un programa que lea una letra y una oración de la entrada estándar (de una sola línea), y calcule la cantidad de palabras que terminan con la letra y están en la oración dada. Asuman que la oración siempre terminará con un punto y que las palabras estarán separadas solo por espacios (no habrá comas ni nada de eso). Asuman también que la oración tendrá siempre al menos una palabra.

Ejemplos:

Letra: s
Oración: La cualidad indispensable para un buen cocinero es la puntualidad pero es también la de los invitados.
Salida: 4

Letra: r
Oración: Un discípulo de quien jamás se pide nada que no pueda hacer nunca hace todo lo que puede.
Salida: 1

Letra: o
Oración: No basta tener buen ingenio lo principal es aplicarlo bien.
Salida: 4

Modifiquen su programa para que cuente las palabras que comienzan con la letra dada.

Este es un ejercicio que los hará pensar y luchar mucho. Intenten hacerlo bajo todos los medios posibles. Todo lo dado hasta ahora basta y sobra para lograrlo. Si no logran realizar esto posteen aquí y los iré guiando, no les daré el código así de entrada porque no tiene caso leer un programa ya hecho si ustedes no intentan realizarlo primero poniendo todas las ganas de aprender. Este curso es para ustedes y requiere todo su esfuerzo. No hay otro medio para aprender a programar. Mi esfuerzo fue escribir esto, ustedes practiquen y practiquen, pregúntenme sus dudas y sigan intentando, o bien posteen aquí. Los frutos se verán al final.

Mucha suerte.

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

Con esto hemos terminado la segunda parte del curso. En la tercera parte del curso aprenderemos a definirnos nuestros propios tipos de datos, o sea, como crear un tipo a nuestro antojo y luego declarar variables de ese tipo. Esto complicará un poquito más las cosas, pero también les dará muchas posibilidades a la hora de programar, ya que con los tipos primitivos de pascal no podemos hacer mucho más.

Saludos a todos y todas.

ScrewFace · 17/01/2012

esta perfecta la explicacion, pero me parece casi lo mismo a un do while , solo con el operador not adelante.
como uso otros lenguajes, nunca habia escuchado de un repeat until.. no es algo muy comun no ?

Vlady_18 · 17/01/2012

Todos los lenguajes tienen siempre al menos tres estructuras de repetición:

FOR
WHILE..DO
DO..WHILE

Lenguajes antigüos tienen REPEAT...UNTIL en vez de DO...WHILE. La diferencia, como bien dices, es que con REPEAT la condición es a la inversa que con DO...WHILE. Pero se mantiene el hecho de que tanto REPEAT...UNTIL como DO...WHILE se ejecutan al menos una vez.

Puedes encontrar REPEAT en algunos otros lenguajes, aunque los modernos o potentes como C, C++, C#, Java, Visual, etc usan DO...WHILE.

Saludos.

kandelak · 19/01/2012

Vlady hola

Veo que pascal está siendo usado para enseñar las estructuras básicas de programación en nuestros dias. Yo lo hacia olvidado y obsoleto.

Mi pregunta es la siguiente: ¿Cuando se termine este curso, los participantes serán capaces de programar programas para contabilidad, para la pequeña empresa y cosas así?

Muchas gracias.

VASM · 20/01/2012

¿Podria servir este programa para el ejercicio 6?

const
ESPACIO =' ';
FIN ='.';
var
letra, CarAnterior, car: char;
contador: integer;
begin
contador := 0;
write('Introduzca la letra: ');
readln(letra);
writeln('Introduzca la frase sin comas y con punto al final: ');
repeat
read(car);
if (car = ESPACIO) or (car = FIN) then
begin
if letra = CarAnterior then contador := contador+1;
end
else
CarAnterior := car;
until car = FIN;
write;
writeln('Las veces que aparece la letra ',letra,' al final son ',contador);
readln;
readln
end.

No lo veo tan difícil.
-----Agregado el 20/1/2012 a las 06 : 31 : 38-----
¡Anda, me quitaron los espacios en blanco de las sangrías! Así no se ve tan claro. ¿Se puede hacer algo para que se coma los espacios?
Un saludo.

Vlady_18 · 20/01/2012

Escrito por kandelak

Vlady hola

Veo que pascal está siendo usado para enseñar las estructuras básicas de programación en nuestros dias. Yo lo hacia olvidado y obsoleto.

Mi pregunta es la siguiente: ¿Cuando se termine este curso, los participantes serán capaces de programar programas para contabilidad, para la pequeña empresa y cosas así?

Muchas gracias.

Por supuesto que sí. Ahora bien, un programa de contabilidad no requiere solo conocimientos de programación sino que también hace falta obviamente saber de contabilidad. Yo no enseñaré aquí acerca de contabilidad o matemáticas financieras, eso está en cada uno, yo enseñaré a programar y a pensar con una lógica adecuada, eso podrán luego aplicarlo a lo que quieran. Algunas cosas requerirán conocimientos extra acerca de otras materias.

Si ya sabes de contabilidad, aplicar las fórmulas para calcular tasas de intereses, facturas y demás, será super sencillo, incluso podrás imprimir planillas, recibos, facturas, etc; todo en Java.

Escrito por VASM

¿Podria servir este programa para el ejercicio 6?

const
ESPACIO =' ';
FIN ='.';
var
letra, CarAnterior, car: char;
contador: integer;
begin
contador := 0;
write('Introduzca la letra: ');
readln(letra);
writeln('Introduzca la frase sin comas y con punto al final: ');
repeat
read(car);
if (car = ESPACIO) or (car = FIN) then
begin
if letra = CarAnterior then contador := contador+1;
end
else
CarAnterior := car;
until car = FIN;
write;
writeln('Las veces que aparece la letra ',letra,' al final son ',contador);
readln;
readln
end.

No lo veo tan difícil.
-----Agregado el 20/1/2012 a las 06 : 31 : 38-----
¡Anda, me quitaron los espacios en blanco de las sangrías! Así no se ve tan claro. ¿Se puede hacer algo para que se coma los espacios?
Un saludo.

Para que el código fuente quede con sangrías y espacios debes colocarlo entre las etiquetas CODE, tal como te muestro aquí:

[code]
Aquí escribes el código fuente
con los espacios y sangrías que quieras.
Mejor dicho, aquí pegas el código.

No olvides las etiquetas tal como te las muestro aquí.
[/code]

Respecto al ejercicio, parece estar todo bien. Hice alguna prueba y funcionó, haz tú algunas otras a ver que pasa.

Saludos.

kandelak · 20/01/2012

Vlady muchas gracias.

sbenitez · 25/01/2012

Escrito por ScrewFace

esta perfecta la explicacion, pero me parece casi lo mismo a un do while , solo con el operador not adelante.
como uso otros lenguajes, nunca habia escuchado de un repeat until.. no es algo muy comun no ?

En realidad son lo mismo, en pascal es repeat until y en c es do while, en los 2 se ejecuta primero las instrucciones del bloque y luego se evalua la condicion, a la inversa del while que primero evalua la condicion y despues si es verdadera ejecuta el codigo del bloque sino sale.

raulexploit · 02/03/2012

Hola de nuevo
en el ejercicio 3, ¿los datos que el usuario debe introducir es A, D, R no? ¿y luego al final que te salga el saldo total?
y ¿la letra X esta para hacerlo mas dificil el ejercicio o tiene alguna funcion?
gracias

edit: ¿ha de ser con repeat? siento tantas preguntas esque no entiendo muy bien el ejercicio jeje

Vlady_18 · 02/03/2012

La idea es esta: Inicialmente se introduce la letra A y un saldo inicial para una cuenta, es decir, un valor con el cual comenzar. Luego, a ese valor se le realizarán depósitos, es decir, se agregará dinero mediante la letra D, y se le realizarán retiros (resta de dinero) mediante la letra R. La X es para indicar que ya no se hará más nada y por lo tanto se mostrará el saldo final.

Por ejemplo, si inicialmente ponemos A 1000 implica que comenzamos con $1000. Entonces imagina que pones esto:

D 500

Con eso depositaste $500, por lo tanto la cuenta ahora tiene $1500. Luego imagina que pones

D 300

Con eso depositaste $300 con lo cual ahora hay $1800.

Imagina que luego pones

R 800

Con eso retiras $800, es decir que ahora tenemos $1000 en la cuenta.

Luego pones X, entonces el programa detecta que ya no se harán transacciones y muestra el total, o sea, $1000.

¿¿¿Se entiende??? Resumiendo, el ejemplo es:

Código:

Espero que eso te aclare un poco las dudas.

Te dejo aquí un EXE como ejemplo de este ejercicio, es decir, el programa ya compilado para que veas como debería quedar:

http://www.4shared.com/file/Oq8AD4J1/Ejercicio.html

Programando desde 0: 10- Repetición condicional con REPEAT...UNTIL

Temas relacionados:

¿Este tema te pareció interesante? Compártelo!

¿No es lo que buscabas? Intenta buscar un tema similar

38 comentarios / 3398 Visitas

¿Eres nuevo?

¿Ya eres parte de la comunidad?

Todo depende de la pausa

Cómo enfocarse en la era de la distracción

Hábitos para una vida más tranquila