Ejercicios de Programación - Soluciones

No sirve absolutamente de nada mirar las soluciones, si previamente no lo habéis intentado resolver

Vuestras soluciones no tienen por qué ser iguales a éstas, pueden ser diferentes y estar bien, preguntad a vuestro profesor.

Dado un nº de autobuses, y las plazas por autobús, escribir su capacidad

algoritmo
var
    autobuses, plazas, capacidad: entero
fvar
    Escribir ("Introduce el número de autobuses:")
    Leer (autobuses)
    Escribir ("Número de plazas por autobús:")
    Leer (plazas)
    capacidad := autobuses * plazas
    Escribir ("Se pueden transportar ", capacidad, " personas")
falgoritmo

Dada una cantidad de libros y de personas, repartidlos y decir cuántos sobran

algoritmo
var
    libros, personas, reparto, sobrante: entero
fvar
    Escribir ("Introduce el número de libros: ")
    Leer (libros)
    Escribir ("Número de personas: ")
    Leer (personas)
    reparto := libros / personas             {división entera}
    sobrante := libros mod personas     {resto de la división}
    Escribir ("Libros por personas:", reparto, " y sobran:", sobrante)
falgoritmo

Dada una cantidad en céntimos (leyendo un sólo nº), escribir su cambio minimizando el número de monedas de euro, 20centimos, 5c y 1c

algoritmo
var
    centimos: entero
fvar
    Escribir ("Introduce la cantidad de céntimos: ")
    Leer (céntimos)
    Escribir (céntimos / 100, " euros")               {división entera}
    céntimos := céntimos mod 100                 {el resto de céntimos quitados los euros}
    Escribir (céntimos / 20, " monedas de 20 céntimos")
    céntimos := céntimos mod 20
    Escribir (céntimos / 5, " monedas de 5 céntimos")
    Escribir (céntimos mod 5, " monedas de 1 céntimo")
falgoritmo

Leer el radio y escribir el perímetro de la circunferencia

algoritmo
var
    radio, perimetro: real
fvar
    Escribir ("Introduce el radio: ")
    Leer (radio)
    perimetro := 2,0 * 3,14 * radio        {todos los números deben ser reales}
    Escribir ("La circunferencia de radio ", radio, "es ", perimetro)
falgoritmo

program circunferecia;
var
    radio perimetro: real;
begin
    write ('Introduce el radio: ');
    read (radio);
    perimetro := 2.0 * 3.14 * radio
    Writeln ('La circunferencia de radio ', radio, 'es ', perimetro);
end.

Pasar una cantidad entera de Ptas a Euros, con solo dos decimales y redondeo en el tercer decimal

algoritmo
var
    ptas: entero
    euro: real
fvar
    Escribir ("Introduce la cantidad en pesetas: ")
    Leer (ptas)
    euro := AReal (ptas) / 166,386 {euros con una cantidad indefinida de decimales}
    euro := euro + 0,005                 {redondeo en el tercer decimal}
    euro := euro * 100,0               {paso dos decimales a la parte entera}
    euro := AReal (AEntero(euro)) {Convierto a entero para perder los decimales, y vuelvo a convertir a real}
    euro := euro / 100,0                 {vuelvo a poner los dos decimales originales en la parte decimal}
    Escribir (euro, " euros")
falgoritmo

Dado un nº de 3 cifras, decir si es capicúa

algoritmo
var
    n: entero
fvar
    Leer (n)
    si (n < 100) o (n > 999) entonces
        Escribir ("Número no válido, debe tener 3 cifras")
    sino
        si (x / 100) = (x mod 10) entonces   {1ª cifra = tercera cifra}
            Escribir ("sí")
        sino
            Escribir ("no")
        fsi
    fsi
falgoritmo

Leer tres números reales y escribir el mayor

algoritmo
var
    num1, num2, num3: entero
fvar
    Escribir ("Introduce tres números: ")
    Leer (num1, num2, num3)
    si num1 > num2 y num1 > num3 entonces
       Escribir ("El mayor es ", num1)
    sino
       si num2 > num3 entonces          {no miro num1 porque ya sé que no es}
           Escribir ("El mayor es ", num2)
       sino
          Escribir ("El mayor es ", num3)
falgoritmo

program mayor_de_3;
var
    num1, num2, num3: integer;
begin
    write ('Introduce tres numeros: ');
    read (num1, num2, num3);
    if (num1 > num2) and (num1 > num3) then begin
        Writeln ('El mayor es ', num1);
    end
    else begin
        if (num2 > num3) then begin
            Writeln ('El mayor es ', num2);
        end
        else begin
            Writeln ('El mayor es ', num3);
        end;
    end;
end.

Leer tres números reales y escribirlos de menor a mayor

algoritmo
var
    num1, num2, num3, aux: entero
fvar
    Escribir ("Introduce tres números: ")
    Leer (num1, num2, num3)
    {A veces un buen análisis del problema nos puede ahorrar mucho trabajo}
    {   y en este caso evitar liarnos con gran cantidad de si-sino enhebrados}
    si num1 > num2 entonces    {si num1 y num2 están desordenados, los intercambio}
       aux := num1
       num1 := num2
       num2 := aux
    fsi
    si num2 > num3 entonces    {si num2 y num3 están desordenados, los intercambio}
       aux := num2
       num2 := num3
       num3 := aux
    fsi
    si num1 > num2 entonces    {repito con num1 y num2, por si num2 hubiera cambiado en el paso anterior}
       aux := num1
       num1 := num2
       num2 := aux
    fsi
    {si no lo veis, haced una traza}
    Escribir (num1, num2, num3)
falgoritmo

Dados 3 números reales a, b y c escribir las raíces, si son reales, de la ecuación de segundo grado ax² + bx + c = 0

algoritmo
var
    a, b, c, discriminante: real
fvar
    Escribir ("Introduce los tres coeficientes de la ecuación de segundo grado, a, b, c: ")
    Leer (a, b, c)
    discriminante := b*b - 4,0*a*c
    si discriminante < 0 entonces
       Escribir ("No tiene soluciones reales")
    sino
       Escribir ((-b + raíz(discriminante)) / (2.0*a))
       Escribir ((-b - raíz(discriminante)) / (2.0*a))
    fsi
falgoritmo

Dado f(x) = 3x² + 5x – 3 escribir los f(x) para x en [1..100]

algoritmo
var
    x: entero
fvar
    x := 1
    mientras x <= 100 hacer
       Escribir (3*x*x + 5*x - 3)
       x := x+1
    fmientras
falgoritmo

RECUERDA: No sirve absolutamente de nada mirar las soluciones si previamente no habéis intentado resolverlo vosotr@s

Dada una secuencia de notas acabada en –1.0 calcular el porcentaje de aprobados

algoritmo
var
    aprobados, total: entero
     nota: real
fvar
    aprobados := 0
    total := 0
    Leer (nota)
    mientras nota <> -1.0 hacer
       si nota >= 5.0 entonces
          aprobados := aprobados + 1
       fsi
       total := total +1
       Leer (nota)
    fmientras
    Escribir ((AReal(aprobados) / AReal(total)) *100,0)
falgoritmo

program porcentaje_aprobados;
var
    aprobados, total: integer;
    nota: real;
begin
    aprobados := 0;
    total := 0;
    read (nota);
    while nota <> -1.0 do begin
        if nota >= 5.0 then begin
          aprobados := aprobados + 1;
        end;
        total := total +1;
        read (nota);
    end;
    Write ((aprobados/total)*100,0);
end.

Dada una frase acabada en '.' contar cuantas veces aparece la secuencia "LA"

algoritmo
var
    anterior, actual: carácter
     contador: entero
fvar
contador := 0
anterior := 'X'              {cualquier valor diferente de 'L', para que no cuente si la primera letra de la frase es una 'A'}
    Leer (actual)
    mientras actual <> '.' hacer
       si anterior = 'L' y actual = 'A' entonces
          contador := contador +1
       fsi
       anterior := actual         {Avanzo una sola letra en la secuencia}
       Leer (actual)
    fmientras
    Escribir (contador)
falgoritmo

Dado un texto acabado en '#' reescribirlo eliminando los comentarios que están entre {...}, teniendo en cuenta que puede haber varios niveles de comentarios

algoritmo
const
    FIN = '#'
fconst
var
    letra: carácter
     contador: entero
fvar
contador := 0
    Leer (letra)
    mientras letra <> FIN hacer
       si letra = '{' entonces                         {se abre un comentario}
          contador := contador +1
       sino
            si letra = '}' entonces                     {se cierra un comentario}
              contador := contador -1
      fsi
       fsi
       si contador = 0 y letra <> '}' entonces   {si es 0, está fuera de comentarios, salvo que sea la última llave}
          Escribir (letra)                                     {si no, no lo escribe por estar dentro de un comentario}
       fsi
       Leer (letra)
    fmientras
    Escribir ('#')                                          {escribo también el último carácter, el centinela}
falgoritmo

RECUERDA: Mejor saber resolver ejercicios sencillos, que entender la solución de ejercicios complejos

Dada una secuencia de notas acabada en -1.0 decir si hay algún sobresaliente

algoritmo
const
    FIN = -1.0
fconst
var
    nota: real
     haysobresaliente: booleano
fvar
    haysobresaliente := falso
    Leer (nota)
    mientras nota <> FIN y no haysobresaliente hacer
       si nota >= 9.0 entonces
          haysobresaliente := cierto
       sino
           Leer (nota)
       fsi
    fmientras
    si haysobresaliente entonces
        Escribir ("Hay al menos un sobresaliente")
    sino
       Escribir ("No hay sobresalientes")
    fsi
falgoritmo

program hay_sobresaliente;
const
    FIN = -1.0
fconst
var
    nota: real;
    haysobresaliente: boolean;
begin
    haysobresaliente := false;
    read (nota);
    while (nota <> FIN) and (not haysobresaliente) do begin
        if nota >= 9.0 then begin
            haysobresaliente := true;
        end
        else begin
            read(nota);
        end;
    end;
    if haysobresaliente then begin
        Writeln ('Hay al menos un sobresaliente');
    end
    else begin
        Writeln ('No hay sobresalientes');
    end;
end.

Dada una secuencia de 100 notas decir si hay más de 10 suspensos

algoritmo
const
    MAX = 100
    MAX_SUSPENSOS = 10
fconst
var
    nota: real
     cont_notas, cont_suspensos: entero
fvar
    cont_suspensos := 0
cont_notas := 1
    mientras cont_notas <= MAX y cont_suspensos <= MAX_SUSPENSOS hacer
       {en lugar de usar el esquema de busqueda con booleanos, ponemos la codición directamente en el mientras}
   Leer (nota)
       si nota < 5.0 entonces
          cont_suspensos := cont_suspensos + 1
       fsi
       cont_notas := cont_notas + 1
    fmientras
    si cont_suspensos > 10 entonces
        Escribir ("Hay más de 10 suspensos")
    sino
    Escribir ("No hay más de 10 suspensos")
    fsi
falgoritmo

Dada un nº de DNI y una secuencia de DNI - nota, decir la nota del DNI

algoritmo {buscar_DNI en secuencia con centinela 0 }
const
    FIN = 0
fconst
var
    DNI, buscar: entero
    nota: real
    encontrado: booleano
fvar
    Escribir (“DNI a buscar: “)
    Leer (buscar)
    encontrado := falso
    Leer (DNI)
    mientras (DNI <> FIN) y (no encontrado) hacer
       Leer (nota)
       si DNI = buscar entonces
           encontrado := cierto
       sino
           Leer (DNI)
       fsi
    fmientras
    si encontrado entonces
       Escribir (“La nota de “, buscar, “ es “, nota)
    sino
       Escribir (“El DNI “, buscar, “ no está matriculado”)
    fsi
falgoritmo

algoritmo   {búsqueda de DNI, con 50 alumnos}
const
    LONG = 50
fconst
var
    DNI, buscar: entero
    nota: real
    I: entero
    encontrado: booleano
fvar
    Escribir (“DNI a buscar: “)
    Leer (buscar)
    encontrado := falso
    I := 1
    mientras (I <= LONG) y (no encontrado) hacer
       Leer (DNI, nota)
       si DNI = buscar entonces
           encontrado := cierto
       fsi
       I := I+1
    fmientras
    si encontrado entonces
       Escribir (“La nota de “, buscar, “ es “, nota)
    sino
       Escribir (“El DNI “, buscar, “ no está matriculado”)
    fsi
falgoritmo

program busca_DNI;   {buscar_DNI en secuencia con centinela 0 }
const
    FIN = 0;
var
    DNI, buscar: longInt; // el tipo integer no acepta nº largo, debe ser longInt
    nota: real;
    encontrado: boolean;

begin
    Write ('DNI a buscar: ');
    read (buscar);
    encontrado := false;
    read (DNI);
    while (DNI <> FIN) and (not encontrado)do begin
        read (nota);
        if DNI = buscar then begin
            encontrado := true;
        end
        else begin
            read (DNI);
        end;
    end;
    if encontrado then begin
        Writeln ('La nota de ', buscar, ' es ', nota:1:2);
    end
    else begin
        Writeln ('El DNI ', buscar, ' no estA matriculado');
    end;
end.

program busca_DNI;
const
    LONG = 50;
var
    DNI, buscar: longInt; // el tipo integer no acepta nº largo, debe ser longInt
    nota: real;
    I: integer;
    encontrado: boolean;

begin
    Write ('DNI a buscar: ');
    read (buscar);
    encontrado := false;
    I := 1;
    while (I <= LONG) and (not encontrado)do begin
        read (DNI, nota);
        if DNI = buscar then begin
            encontrado := true;
        end;
        I := I+1;
    end;
    if encontrado then begin
        Writeln ('La nota de ', buscar, ' es ', nota:1:2);
    end
    else begin
        Writeln ('El DNI ', buscar, ' no está matriculado');
    end;
end.

Combinación: Contabilidad de 12 meses, y por cada una secuencia de ingresos - gastos acabada en -1

algoritmo     {Primero de combinación}
const
    FIN = -1
fconst
var
    ingreso, gasto, beneficio: entero
fvar
    beneficio:= 0
    Leer (ingreso)
    mientras ingreso <> FIN hacer
        Leer (gasto)
        beneficio := beneficio + ingreso - gasto
        Leer (ingreso)
    fmientras
    Escribir (“Contabilidad total: ”, beneficio)
falgoritmo

algoritmo     {Segundo de combinación}
const
    MESES = 12
    MAXIMO = 1000
    MINIMO =-1000
fconst
var
    mes, mesmax, mesmin, max, min, beneficio: entero
fvar
    max := MINIMO
    min := MAXIMO
    mes := 1
    mientras mes <= MESES hacer
        Leer (beneficio)
        si beneficio > max entonces
            max := beneficio
            mesmax := mes
        fsi
        si beneficio < min entonces
            min := beneficio
            mesmin := mes
        fsi
        mes := mes +1
    fmientras
    Escribir (“Mes máximo beneficio: “, mesmax)
    Escribir (“Mes mínimo beneficio: “, mesmin)
falgortmo

algoritmo   {combinación de los dos ejercicios simples}
const
    MESES = 12
    MAXIMO = 1000
    MINIMO =-1000
    FIN = -1
fconst
var
    mes, mesmax, mesmin, max, min, beneficio: entero
    ingreso, gasto: entero
fvar
    max := MINIMO
    min := MAXIMO
    mes := 1
    mientras mes <= MESES hacer
        beneficio:= 0
        Leer (ingreso)
        mientras ingreso <> FIN hacer
            Leer (gasto)
            beneficio := beneficio + ingreso - gasto
            Leer (ingreso)
        fmientras
        si beneficio > max entonces
            max := beneficio
            mesmax := mes
        fsi
        si beneficio < min entonces
            min := beneficio
            mesmin := mes
        fsi
        mes := mes +1
    fmientras
    Escribir (“Mes máximo beneficio: “, mesmax)
    Escribir (“Mes mínimo beneficio: “, mesmin)
falgoritmo

program combina1;
const
    FIN = -1;
var
    ingreso, gasto, beneficio: integer;
begin
    beneficio:= 0;
    read (ingreso);
    while ingreso <> FIN do begin
        read (gasto);
        beneficio := beneficio + ingreso - gasto;
        read (ingreso);
    end;
    Writeln ('Contabilidad total: ', beneficio);
end.

program combina2;
const
    MESES = 12;
    MAXIMO = 1000;
    MINIMO =-1000;
var
    mes, mesmax, mesmin, max, min, beneficio: integer;
begin
    max := MINIMO;
    min := MAXIMO;
    mes := 1;
    while mes <= MESES do begin
        read (beneficio);
        if beneficio > max then begin
            max := beneficio;
            mesmax := mes;
        end;
        if beneficio < min then begin
            min := beneficio;
            mesmin := mes;
        end;
        mes := mes +1;
    end;
    writeln ('Mes mAximo beneficio: ', mesmax); // no usar acentos, los escribe mal
    writeln ('Mes mInimo beneficio: ', mesmin);
end.

program combinacion_completa;
const
    MESES = 12;
    MAXIMO = 1000;
    MINIMO =-1000;
    FIN = -1;
var
    mes, mesmax, mesmin, max, min, beneficio: integer;
    ingreso, gasto: integer;

begin
    max := MINIMO;
    min := MAXIMO;
    mes := 1;
    while mes <= MESES do begin
        beneficio:= 0;
        read (ingreso);
        while ingreso <> FIN do begin
            read (gasto);
            beneficio := beneficio + ingreso - gasto;
            read (ingreso);
        end;
        if beneficio > max then begin
            max := beneficio;
            mesmax := mes;
        end;
        if beneficio < min then begin
            min := beneficio;
            mesmin := mes;
        end;
        mes := mes +1;
    end;
    writeln ('Mes mAximo beneficio: ', mesmax); // no usar acentos, los escribe mal
    writeln ('Mes mInimo beneficio: ', mesmin);
end.

Escribir un procedimiento que dado un carácter, si es mayúscula lo pase a minúscula

procedimiento AMinuscula (e_s c: Carácter)   //parámetro de entrada/salida
// si c es mayúscula lo pasa a minúscula, si no, no hace nada
        si ('A'<= c) y (c<='Z') entonces
            c := ACarácter (AEntero(c)-AEntero('A')+AEntero('a'))
        fsi
fprocedimiento

procedure AMinuscula (var c:char);
// si c es mayúscula lo pasa a minúscula, si no, no hace nada
begin
    if ('A'<= c) and (c<='Z') then begin
        c := Chr (Ord(c)-Ord('A')+Ord('a'));
    end;
end;

Hacer una función que dados 2 números calcule su potencia por medio de productos

función potencia (ent base, exponente: entero): entero
{Recibe dos números, el exponente debe ser positivo}
{Devuelve la base elevada al exponente}
var
     resultado: entero
fvar
    resultado := 1
    mientras exponente > 0 hacer
       resultado := resultado * base
       exponente := exponente - 1
    fmientras
    potencia := resultado
falgoritmo

function potencia (ent base, exponente: integer): integer;
{Recibe dos números, el exponente debe ser positivo}
{Devuelve la base elevada al exponente}
var
     resultado: integer;
begin
    resultado := 1;
    while exponente > 0 do begin
       resultado := resultado * base;
       exponente := exponente - 1;
    end;
    potencia := resultado;
end;

Escribir una función que calcule el máximo común divisor de dos números por medio del algoritmo de Euclides

función mcd (ent a, b: entero): entero
{Recibe dos números positivos}
{Devuelve su máximo común divisor}
    mientras a <> b hacer
       si a > b entonces
          a := a-b
       sino
          b := b-a
       fsi
    fmientras
    mcd := a
falgoritmo

Dado un recorrido como una secuencia de puntos (x,y), reales, acabada en el pto (-1.0, -1.0), calcular la distancia recorrida (siempre habrá al menos 2 puntos)

program recorrido;
function distancia (x1, y1, x2, y2: real):real;
// calcula la distancia entre dos puntos
   begin
        distancia := sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
   end;
var
   x1,y1,x2,y2,total: real;
begin
   total := 0.0;
   read (x1, y1);
   read (x2, y2);     // si no dijeran que hay más de dos puntos se podría copiar (x1,y1) en (x2,y2)
   while (x2 <> -1.0) and (y2 <> -1.0) do begin
        total := total + distancia (x1, y1, x2, y2);
        x1 := x2;         //guardo el punto anterior, y leo el nuevo punto
        y1 := y2;
        read (x2, y2);
   end;
   writeln ('Distancia recorrida: ', total:1:2);
end.

Leer una palabra (secuencia de hasta 20 caracteres acabada en blanco) y escribirla al revés

algoritmo
   const MAX = 20 fconst
   tipos
   Tpalabra == tabla [1..MAX] de carácter
   ftipos
   var
   pal: Tpalabra
   c: carácter
   I: entero
   fvar
   I := 0
   Leer (c)
   mientras c <> ' ' hacer
       I := I +1
       pal [I] := c
       Leer (c)
   fmientras
    mientras I > 0 hacer
        Escribir (pal[I])
        I := I -1        {decreciendo}
     fmientras
falgoritmo

Definir una matriz 5 x 5, y hacer un subprograma que devuelva su matriz traspuesta

tipos
    matriz5x5 == tabla [1..5, 1..5] de entero
ftipos

función traspuesta (ent mat: matriz5x5): matriz5x5
{Recibe una matriz}
{Devuelve su traspuesta}
var
    trasp: matriz5x5
    I, J: entero
fvar
    I := 1
    mientras I <= 5 hacer
       J := 1
       mientras J <= 5 hacer
          trasp [I,J] := mat [J,I]
          J := J+1
       fmientras
       I := I +1
    fmientras
    traspuesta := trasp
falgoritmo

Realizar la misma función, pero haciendo la traspuesta sobre la misma matriz, sin usar otra matriz auxiliar, si no intercambiando valores (cuidado de no intercambiarlos dos veces)

Matriz producto

procedimiento MultiplicarMatrices (ent mat1, mat2: Tmatriz, sal matriz: Tmatriz)
   var
        fila,col, I: entero
    fvar
        fila:=1
        mientras fila ≤ MAX hacer
            col:=1
            mientras col ≤ MAX hacer
                matriz [fila,col] := 0
                I:=1
                mientras I ≤ MAX hacer
                    matriz [fila,col] := matriz [fila,col] + mat1 [fila,I] + mat2 [I,col]
                    I:=I+1
                fmientras
                col:=col+1
            fmientras
            fila:=fila+1
        fmientras
fprocedimiento