A continuación se enumeran los criterios que se utilizaron para la corrección del parcial. Estos se basan en la identificación de posibles errores que se pueden cometer al resolver los ejercicios, clasificados por su gravedad. Se trata de un conjunto de criterios generales, pueden haber errores puntuales no cubiertos directamente por estos criterios que se analizan caso a caso.

El código presentado (en rojo) para cada error es un ejemplo posible, podrían haber otros errores en la implementación que estén contemplados dentro del mismo criterio.

Criterios Parte A

Graves

Asigna los dos resultados a la misma variable y por lo tanto pierde información
procedure siguienteDigito(var num: Natural; var digito: Integer);
begin
  digito := num mod 10;
  digito := num div 10
end;
En lugar de tomar el valor del parámetro `num` lo toma de la entrada estandar
procedure siguienteDigito(var num: Natural; var digito: Integer);
var aux: Natural;
begin
  read(aux);
  digito := aux mod 10;
  num := aux div 10
end;
En lugar de asignar los valores a los parámetros los despliega en la salida
procedure siguienteDigito(var num: Natural; var digito: Integer);
begin
  writeln(num mod 10);
  writeln(num div 10)
end;
Usa división real en lugar de entera (aunque la intente corregir con trunc)
procedure siguienteDigito(var num: Natural; var digito: Integer);
begin
  digito := num mod 10;
  num := trunc(num / 10);
end;
Actualiza solamente uno de los parámetros de entrada (num, pero no digito o digito, pero no num)

procedure siguienteDigito(var num: Natural; var digito: Integer);
begin
  digito := num mod 10;
end;

Itera
procedure siguienteDigito(var num: Natural; var digito: Integer);
var original: Integer;
begin
  original:=num;
  while (num > 10) do num := num div 10;
  digito := num;
  num := original
end;
Algoritmo incorrecto
 

Medios

Retorna algún resultado como si fuera una función
procedure siguienteDigito (var num: Natural; var digito: Integer);
begin
  digito := num mod 10;
  siguienteDigito := num div 10
end;
Asigna algún resultado a una variable local y no al parámetro adecuado
procedure siguienteDigito (var num: Natural; var digito: Integer);
var digitoLocal, numLocal: Integer;
begin
  digitoLocal := num mod 10;
  numLocal := num div 10
end;
Retorna en digito el resultado de div 10 y en num el resultado de mod 10
procedure siguienteDigito (var num: Natural; var digito: Integer);
begin
  num := num mod 10;
  digito := num div 10
end;
 
Escribe algo en la salida (no acumula con el grave de salida)

procedure siguienteDigito (var num: Natural; var digito: Integer);
begin
  digito := num mod 10;
  num := num div 10;
  writeln(num)
end;

Invierten las dos instrucciones (primero el div y luego el mod), por lo que pierde el dígito que en realidad se quiere obtener

procedure siguienteDigito (var num: Natural; var digito: Integer);
begin
  num := num div 10;
  digito := num mod 10;
end;

Considera a digito como un parámetro de entrada

Leves

Controla `num > 0` o algún caso de borde innecesario

procedure siguienteDigito (var num: Natural; var digito: Integer);
begin
  if num >= 10 then begin
    digito := num mod 10;
    num := num div 10
  end
  else begin
    digito := num;
    num := 0
  end
end;

Actualiza num restando digito
procedure siguienteDigito (var num: Natural; var digito: Integer);
begin
  digito := num mod 10;
  num := (num-digito) div 10;
end;

 

Criterios Parte B

 

Graves

Utiliza diez variables, hace un case para distinguir el dígito ingresado y resuelve mal o resuelve bien pero no corta la iteración cuando la cantidad de ocurrencias supera a `cant`
function esCantidadDe (cant : integer; dig : integer; num : Natural) : boolean;
var digito, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9 : integer;
begin
  c0:=0;c1:=0;c2:=0;c3:=0;c4:=0;c5:=0;c6:=0;c7:=0;c8:=0;c9:=0;
  while (num <> 0) and (cant >= 0) do
  begin
    siguienteDigito(num, digito);
    case digito of
      0: c0:=c0+1;
      1: c1:=c1+1;
      2: c2:=c2+1;
      3: c3:=c3+1;
      4: c4:=c4+1;
      5: c5:=c5+1;
      6: c6:=c6+1;
      7: c7:=c7+1;
      8: c8:=c8+1;
      9: c9:=c9+1;
    end;
  end;
  esCantidadDe := <CONDICION INCORRECTA>
end;
Ignora dig (no acumula con el anterior)
function esCantidadDe (cant : integer; dig : integer; num : Natural) : boolean;
var digito : integer;
begin
  while (num <> 0) and (cant >= 0) do
  begin
    siguienteDigito(num, digito);
    cant := cant - 1
  end;
  esCantidadDe := cant = 0
end;
Invoca un procedimiento como si fuera una función

function esCantidadDe (cant : integer; dig : integer; num : Natural) : boolean;
var digito : integer;
begin
  while (num <> 0) and (cant >= 0) do
  begin
    digito := siguienteDigito(num, digito);
    if digito = dig then cant := cant - 1
  end;
  esCantidadDe := cant = 0
end;

Usa for
function esCantidadDe (cant : integer; dig : integer; num : Natural) : boolean;
var digito, i : integer;
begin
  for i := 1 to 8 do
  begin
    siguienteDigito(num, digito);
    if digito = dig then cant := cant - 1
  end;
  esCantidadDe := cant = 0
end;
No usa ninguna estructura de iteración
function esCantidadDe (cant : integer; dig : integer; num : Natural) : boolean;
var digito : integer;
begin
  siguienteDigito(num, digito);
  if digito = dig then cant := cant - 1;
  esCantidadDe := cant = 0
end;

Medios-Graves

No corta la iteración cuando la cantidad de ocurrencias supera a `cant`
function esCantidadDe (cant : integer; dig : integer; num : Natural) : boolean;
var digito : integer;
begin
  while (num <> 0) do
  begin
    siguienteDigito(num, digito);
    if digito = dig then cant := cant - 1
  end;
  esCantidadDe := cant = 0
end;

Medios

Usa un contador sin inicializar
function esCantidadDe (cant : integer; dig : integer; num : Natural) : boolean;
var digito, contador : integer;
begin
  while (num <> 0) and (contador <= cant) do
  begin
    siguienteDigito(num, digito);
    if digito = dig then contador := contador + 1
  end;
  esCantidadDe := contador = cant
end;
Usa el nombre de la función como variable
function esCantidadDe (cant : integer; dig : integer; num : Natural) : boolean;
var digito : integer;
begin
  esCantidadDe := false;
  while (num <> 0) and (cant >= 0) do
  begin
    siguienteDigito(num, digito);
    if digito = dig then cant := cant - 1
  end;
  if cant = 0 then esCantidadDe:= not esCantidadDe
end;
Calcula el resultado pero no lo retorna, o lo retorna mal (ej. usando return)
function esCantidadDe (cant : integer; dig : integer; num : Natural) : boolean;
var digito : integer;
begin
  while (num <> 0) and (cant >= 0) do
  begin
    siguienteDigito(num, digito);
    if digito = dig then cant := cant - 1
  end;
  return cant = 0
end;
Cortar al llegar al número de ocurrencias en lugar de al pasarse (con condiciones como < cant o cant > 0)
function esCantidadDe (cant : integer; dig : integer; num : Natural) : boolean;
var digito : integer;
begin
  while (num <> 0) and (cant > 0) do
  begin
    siguienteDigito(num, digito);
    if digito = dig then cant := cant - 1
  end;
  esCantidadDe := cant = 0
end;

Leves

Usa if para asignar la condición en lugar de asignarla directamente
function esCantidadDe (cant : integer; dig : integer; num : Natural) : boolean;
var digito : integer;
begin
  while (num <> 0) and (cant >= 0) do
  begin
    siguienteDigito(num, digito);
    if digito = dig then cant := cant - 1
  end;
  if cant = 0 then
    esCantidadDe := true
  else
    esCantidadDe := false;
end;
No usa siguienteDigito
function esCantidadDe (cant : integer; dig : integer; num : Natural) : boolean;
var digito : integer;
begin
  while (num <> 0) and (cant >= 0) do
  begin
    digito := num mod 10;
    num := num div 10;
    if digito = dig then cant := cant - 1
  end;
  esCantidadDe := cant = 0
end;
Casos de borde innecesarios

Última modificación: lunes, 19 de mayo de 2025, 18:30