Apéndice A. El juez automático¶
Los ejercicios de programación del curso se entregan y se califican en un juez automático: un servidor que compila cada envío, lo corre contra juegos de datos que nadie vio antes y devuelve un veredicto. Esta nota es el recorrido completo —entrar, leer un enunciado, probar en la máquina propia, enviar, interpretar la respuesta— y termina con la ficha técnica del servidor, que resuelve buena parte de las preguntas que aparecen a mitad de una tarea.
El juez del curso es DOMjudge 7.0.3 y vive en
arena.javerianacali.edu.co.
Dos detalles de la dirección
Va con http, no con https: el puerto 443 acepta la conexión pero nunca
completa el saludo TLS. Y termina en /domjudge/team; el marcador público
está en /domjudge/public.
Si la página no carga, lo primero que hay que revisar es que no haya una VPN comercial encendida. El servidor está dentro de la red de la Universidad y varias VPN lo dejan inalcanzable.
Diapositivas¶
Qué hace el servidor con un envío¶
Cuando se sube un archivo fuente, el servidor:
- Lo compila con la misma línea de compilación para todo el mundo.
- Lo ejecuta con varios juegos de datos que el estudiante no conoce.
- Le da a cada ejecución un tope de tiempo y de memoria.
- Compara la salida producida con la salida esperada.
- Devuelve un veredicto.
Nada de eso es interactivo. El programa lee de la entrada estándar, escribe en la
salida estándar y termina. No pide datos, no muestra menús, no lee archivos y no
espera que alguien esté mirando la pantalla. En la práctica el servidor conecta un
archivo a la entrada del programa y guarda en otro archivo lo que el programa
escriba: exactamente lo que uno hace en la terminal con
./sol < entrada.txt > salida.txt.
De ahí salen dos costumbres que hay que desaprender:
| Programa de clase | Programa para el juez |
|---|---|
| Saluda al usuario | No saluda |
| Pide el dato: «Ingrese n» | Lee el dato sin anunciarlo |
| Explica el resultado | Escribe solo el resultado |
| Resuelve un caso y termina | Resuelve todos los casos que vengan |
El recorrido¶
Entrar¶

Desde la portada del servidor se sigue el enlace Team interface y ahí se escriben las credenciales del curso.
Elegir el concurso¶
Arriba a la derecha hay un selector con los concursos disponibles. Cada tarea es un concurso distinto, y el problema solo aparece si está seleccionado el concurso correcto. Es la causa número uno de «no me sale el problema».
Abrir el enunciado¶

En Problemset está la lista de problemas. El botón problem text abre el PDF; input y output descargan el ejemplo oficial, y zip with all samples los trae juntos.

Enviar¶

Se sube el archivo fuente, no el ejecutable ni un comprimido, y se revisa que el problema y el lenguaje sean los que corresponden. El campo Entry point solo se llena en lenguajes que lo piden, como Kotlin; para C, C++ y Python se deja vacío.
El problema de la demostración¶
El concurso de práctica trae The 3n + 1 problem, que es el problema 100 de UVa: https://vjudge.net/problem/UVA-100.
Statement
Consider the following algorithm applied to a positive integer \(n\): if \(n\) is 1, the algorithm stops; if \(n\) is even, \(n\) is replaced by \(n/2\); otherwise, \(n\) is replaced by \(3n + 1\).
The cycle length of \(n\) is the amount of numbers that the algorithm visits, including \(n\) itself and the final 1.
For every pair of numbers \(i\) and \(j\), determine the maximum cycle length over all numbers between and including \(i\) and \(j\).
Partiendo de 22 el algoritmo visita
Son 16 números contando el 22 del principio y el 1 del final, así que la longitud de ciclo de 22 es 16.
Formatos¶
La entrada es una sucesión de pares \(i\), \(j\), uno por línea, y se procesa hasta que se acabe el archivo: cuántos pares hay no se anuncia en ninguna parte. Por cada par se imprime una línea con \(i\), \(j\) y la longitud de ciclo máxima, separados por un espacio.
1 10
100 200
201 210
900 1000
1 10 20
100 200 125
201 210 89
900 1000 174
Las dos trampas¶
El orden del par
Nada obliga a que \(i\) sea menor que \(j\). El intervalo hay que recorrerlo del
menor al mayor, pero al imprimir van \(i\) y \(j\) como llegaron. Con la entrada
10 1 la respuesta es 10 1 20, no 1 10 20 ni 10 1 0.
El tamaño de los números
Aunque \(i\) y \(j\) se quedan por debajo de un millón, los valores intermedios de
la sucesión suben mucho más. Hay que usar un tipo de 64 bits: long long en C.
La solución¶
/* The 3n+1 problem: por cada par i j se busca la
longitud de ciclo mas grande del intervalo. */
#include <stdio.h>
/* Cuantos numeros visita el algoritmo desde n hasta
llegar a 1, contando los dos extremos. */
long long longitud(long long n)
{
long long cuenta;
cuenta = 1;
while (n > 1)
{
if (n % 2 == 0)
{
n = n / 2;
}
else
{
n = 3 * n + 1;
}
cuenta = cuenta + 1;
}
return cuenta;
}
int main(void)
{
long long i, j, desde, hasta, n, mejor, actual;
while (scanf("%lld %lld", &i, &j) == 2)
{
/* El intervalo se recorre de menor a mayor;
i y j se imprimen como llegaron. */
desde = i;
hasta = j;
if (desde > hasta)
{
desde = j;
hasta = i;
}
mejor = 0;
n = desde;
while (n <= hasta)
{
actual = longitud(n);
if (actual > mejor)
{
mejor = actual;
}
n = n + 1;
}
printf("%lld %lld %lld\n", i, j, mejor);
}
return 0;
}
Y la misma idea en C++, donde solo cambian la lectura y la escritura:
/* The 3n+1 problem, version en C++. Misma idea que
en C; cambian la lectura y la escritura. */
#include <iostream>
long long longitud(long long n)
{
long long cuenta;
cuenta = 1;
while (n > 1)
{
if (n % 2 == 0)
{
n = n / 2;
}
else
{
n = 3 * n + 1;
}
cuenta = cuenta + 1;
}
return cuenta;
}
int main()
{
long long i, j, desde, hasta, n, mejor, actual;
while (std::cin >> i >> j)
{
desde = i;
hasta = j;
if (desde > hasta)
{
desde = j;
hasta = i;
}
mejor = 0;
n = desde;
while (n <= hasta)
{
actual = longitud(n);
if (actual > mejor)
{
mejor = actual;
}
n = n + 1;
}
std::cout << i << " " << j << " "
<< mejor << "\n";
}
return 0;
}
Por cada par se recorren \(|j - i| + 1\) números, y por cada número se sigue su
cadena hasta llegar a 1. Si \(L\) es la cadena más larga del intervalo, un par
cuesta \(O((|j-i|+1) \cdot L)\) y el espacio es \(O(1)\). El intervalo completo,
1 999999, se resuelve en unos \(0{,}2\) segundos contra un tope de 3, así que la
solución directa alcanza sin guardar resultados intermedios.
Probar antes de enviar¶
El ciclo de trabajo local son cuatro pasos y tres comandos:
gcc -Wall -Wextra 3n1.c -o sol
./sol < 3n1.in > salida.out
diff salida.out 3n1.out
Si diff no imprime nada, las dos salidas son idénticas. Esa es la señal para
enviar. Cuando sí hay diferencia, responde así:
1c1
< 10 1 0
---
> 10 1 20
1c1 dice que la línea 1 del primer archivo hay que cambiarla por la línea 1 del
segundo. Las líneas con < son las que produjo el programa; las que llevan >,
las que se esperaban.
Ver los caracteres que no se ven
Un espacio al final de la línea o un salto de línea faltante no se distinguen
a simple vista. cat -A los muestra: marca el final de cada línea con $ y
los tabuladores con ^I.
./sol < 3n1.in | cat -A | head -3
Los casos que el ejemplo no trae¶
El ejemplo oficial es el caso amable: en sus cuatro líneas \(i\) siempre es menor
que \(j\). Vale la pena agregar a mano un par al revés (10 1), un par de un solo
número (22 22), el intervalo más grande que permita el enunciado y una entrada
vacía, que debe producir salida vacía sin quedarse colgado.
Pasar el ejemplo no garantiza el veredicto
Los juegos de datos del servidor son otros y más grandes, e incluyen los extremos. Un programa que solo se probó con el ejemplo del enunciado llega al juez sin haber visto sus casos difíciles.
Los veredictos¶

Los tres programas de la imagen compilan sin errores y los tres calculan longitudes de ciclo. Solo uno pasó.
| Veredicto | Qué revisar |
|---|---|
CORRECT |
Nada. La solución pasó todos los juegos de datos. |
WRONG-ANSWER |
El formato de salida, los casos límite y el desbordamiento de los tipos. |
TIMELIMIT |
El costo del algoritmo, o un ciclo que no termina cuando se acaba la entrada. |
RUN-ERROR |
Índices fuera de rango, división entre cero, memoria no reservada, o un return distinto de cero. |
NO-OUTPUT |
El programa terminó sin escribir nada: se cayó antes de imprimir, o quedó esperando una entrada que no llega. |
OUTPUT-LIMIT |
Un ciclo que imprime sin parar. |
MEMORY-LIMIT |
Reservas desmedidas, o recursión que no toca fondo. |
COMPILER-ERROR |
El código no compila con la línea del servidor. |
El que dio WRONG-ANSWER¶
/* Version que NO pasa: supone que i siempre viene
antes que j. Pasa el ejemplo del enunciado. */
#include <stdio.h>
long long longitud(long long n)
{
long long cuenta;
cuenta = 1;
while (n > 1)
{
if (n % 2 == 0)
{
n = n / 2;
}
else
{
n = 3 * n + 1;
}
cuenta = cuenta + 1;
}
return cuenta;
}
int main(void)
{
long long i, j, n, mejor, actual;
while (scanf("%lld %lld", &i, &j) == 2)
{
mejor = 0;
n = i;
while (n <= j)
{
actual = longitud(n);
if (actual > mejor)
{
mejor = actual;
}
n = n + 1;
}
printf("%lld %lld %lld\n", i, j, mejor);
}
return 0;
}
Con el ejemplo del enunciado da bien: sus cuatro pares vienen en orden creciente,
así que hace lo mismo que la solución buena. Cuando llega 10 1, en cambio, la
condición n <= j es falsa desde el principio, el ciclo no entra nunca, mejor se
queda en 0 y el programa imprime 10 1 0. El servidor sí prueba pares al revés.
El que dio TIMELIMIT¶
/* Version que agota el tiempo: por cada par recorre
desde 1 y descarta lo que quede por debajo de i.
Las respuestas son correctas; el costo, no. */
#include <stdio.h>
long long longitud(long long n)
{
long long cuenta;
cuenta = 1;
while (n > 1)
{
if (n % 2 == 0)
{
n = n / 2;
}
else
{
n = 3 * n + 1;
}
cuenta = cuenta + 1;
}
return cuenta;
}
int main(void)
{
long long i, j, desde, hasta, n, mejor, actual;
while (scanf("%lld %lld", &i, &j) == 2)
{
desde = i;
hasta = j;
if (desde > hasta)
{
desde = j;
hasta = i;
}
mejor = 0;
n = 1;
while (n <= hasta)
{
actual = longitud(n);
if (n >= desde && actual > mejor)
{
mejor = actual;
}
n = n + 1;
}
printf("%lld %lld %lld\n", i, j, mejor);
}
return 0;
}
Esta sí ordena el par, pero por cada consulta arranca el recorrido en 1 en lugar de
arrancar en el extremo menor. El filtro n >= desde descarta lo que sobra, así que
las respuestas son correctas: el problema no es qué calcula sino cuánto le cuesta.
Con cien pares estrechos cerca del millón, la versión buena tarda cinco milésimas y
esta casi 20 segundos. El tope es de 3.
Qué dice ese veredicto
TIMELIMIT no señala un error de lógica sino uno de costo. Revisar la salida
no sirve: hay que contar cuántas operaciones hace el programa, que es
justamente el análisis de complejidad del curso. La pregunta es cuántas veces
se ejecuta el ciclo más interno en el peor caso.
El marcador¶

Los envíos fallidos quedan registrados y suman penalización: 20 minutos por cada intento fallido de un problema que después se resuelve. Los errores de compilación también cuentan.
Cómo compara el juez la salida¶
Este es el punto que más malentendidos produce, así que vale la pena decir exactamente qué hace el servidor del curso. El comparador es el validador por defecto de Kattis, que DOMjudge trae compilado, invocado sin opciones. Lee las dos salidas —la del estudiante y la esperada— token por token, donde un token es cualquier cosa separada por espacios en blanco. Con esa configuración:
- Los espacios en blanco entre tokens no importan: da lo mismo un espacio que tres, o un salto de línea que un tabulador. Los saltos de línea al final tampoco.
- Las mayúsculas no importan:
YESyyescuentan como el mismo token. - Un token de más al final es
WRONG-ANSWER, con el mensaje trailing output. - Un token de menos también, con el mensaje user EOF while judge had more output.
- Si los dos tokens son texto y difieren, es
WRONG-ANSWERen la línea donde ocurrió.
Esto es lo que hace hoy, no un permiso
Que el comparador tolere espacios no es razón para descuidar el formato. Un problema puede traer su propio comparador —más estricto, o con tolerancia numérica— y el enunciado manda siempre. La costumbre sana es imprimir exactamente lo que pide el enunciado.
Lo que sí conviene recordar es lo contrario: el saludo, el «Ingrese n» o el «El resultado es:» son tokens de más y hunden un programa que calcula bien.
Ficha técnica del servidor¶
Los valores de esta tabla se leyeron de la configuración del servidor del curso el 20 de agosto de 2026.
| Qué | Valor |
|---|---|
| Versión | DOMjudge 7.0.3 sobre Apache 2.4.38 |
| Interfaz de equipo | http://arena.javerianacali.edu.co/domjudge/team |
| Lenguajes habilitados | C (.c), C++ (.cpp, .cc, .cxx, .c++), Python 3 (.py) |
| Compilación de C | gcc -x c -Wall -O2 -static -pipe -o programa fuente.c -lm |
| Compilación de C++ | g++ -x c++ -Wall -O2 -static -pipe -o programa fuente.cpp |
| Tope de tiempo | el que fije cada problema (3 s en la demostración) |
| Margen antes de matar el proceso | 1 s o 10 % del tope, el mayor de los dos |
| Memoria por ejecución | 2 000 000 kB, ajustable por problema |
| Salida máxima | 500 000 kB; lo que exceda se trunca |
| Procesos por envío | 64 |
| Tamaño del fuente | 256 kB, hasta 100 archivos por envío |
| Comparador por omisión | validador por defecto de Kattis, sin opciones |
| Salida del compilador | siempre visible para el equipo |
| Diff contra el ejemplo | deshabilitado |
| Penalización | 20 minutos por envío fallido, errores de compilación incluidos |
Tres consecuencias prácticas de esa lista:
El juez compila con -O2 y sin -Wextra. Compilar en casa con
gcc -Wall -Wextra es más estricto que el servidor, que es como debe ser. Lo que
no aparece en casa y sí en el juez son los efectos de la optimización sobre código
con comportamiento indefinido: una variable sin inicializar puede dar bien en la
máquina propia y mal allá.
La salida del compilador siempre se puede leer. Al abrir el envío en la
interfaz de equipo aparecen las advertencias, incluso cuando el veredicto fue
CORRECT. Es información gratis: una advertencia de -Wall en un programa que dio
WRONG-ANSWER suele ser el error.
La evaluación se detiene en la primera falla. El servidor no sigue corriendo los juegos de datos restantes una vez encuentra el veredicto definitivo, así que el número de casos que pasaron antes no dice mucho sobre qué tan cerca estuvo la solución.
Errores frecuentes¶
- «No aparece el problema.» Casi siempre es el concurso equivocado en el selector de arriba a la derecha, o un concurso que todavía no empieza o que ya cerró. Fuera de la ventana del concurso el botón Submit no acepta envíos.
- Subir el ejecutable o un
.zip. Se envía el.co el.cpp. - Elegir mal el lenguaje. Un
.cppenviado como C daCOMPILER-ERROR. - Leer un solo caso. El programa tiene que leer hasta el final del archivo. En
C,
scanfdevuelve cuántos valores logró leer —2 mientras haya par,EOFal final—; en C++,std::cin >> i >> jse evalúa como falso cuando ya no hay nada. Al probar a mano, el final del archivo se produce con Ctrl+D en Linux y macOS, o Ctrl+Z y Enter en Windows. - Dejar
system("pause"),getch()oconio.h. No existen en el servidor y, si existieran, dejarían el programa esperando para siempre. - Imprimir un
long longcon%d. El formato es%lld. - Confiar en el reloj del sitio. Las horas que muestra el servidor están en el huso de Nueva York, que entre marzo y noviembre va una hora adelante de Colombia. La fecha de cierre que vale es la que anuncia el curso; el contador de la esquina superior derecha, que dice cuánto falta, es la referencia confiable dentro del sitio.
Pedir una aclaración¶
La interfaz de equipo tiene un botón request clarification que deja la pregunta registrada y con respuesta visible. Es para lo que de verdad lo necesita: un problema del servidor, un enunciado ambiguo o un juego de datos que contradiga lo enunciado.
Antes de escribirla conviene releer el formato de salida y probar el caso que se cree contradictorio. La mayoría de las dudas se resuelven ahí mismo.
Antes de oprimir Submit¶
- El programa no imprime nada que el enunciado no pida.
- Lee hasta el final del archivo, no un solo caso.
- Compila con
-Wall -Wextray sin advertencias. diffcontra el ejemplo oficial no dice nada.- Se probaron los casos límite que el ejemplo no trae.
- Los tipos aguantan los valores intermedios.
- En el formulario, el problema y el lenguaje son los que corresponden.
De quién es la responsabilidad
Verificar la solución antes de enviarla es parte del trabajo, no un paso opcional. Un envío que falla por no haber probado —salida con texto de más, un solo caso leído, un tipo que se desborda, un ciclo que no termina— corre por cuenta de quien lo envió.
No se aceptan como reclamo que el programa «funcionaba en mi máquina», que «el ejemplo del enunciado daba bien» o que «se subió el archivo equivocado». Los tres se evitan con la lista de arriba, y los tres se revisan en menos de un minuto.
Y una advertencia adicional: hay cuatro cursos dependiendo del mismo servidor. Una recursión infinita o una falla de segmentación probada allá, en vez de probada en casa, afecta a todo el mundo. El sistema deja registro de quién envió qué.
Archivos de esta nota¶
3n1.c— la solución, en C.3n1.cpp— la misma, en C++.3n1.iny3n1.out— el ejemplo oficial.3n1-sinorden.c— la versión que daWRONG-ANSWER.3n1-lento.c— la que daTIMELIMIT.
Referencias¶
- DOMjudge Team. DOMjudge Team Manual. domjudge.org/docs/manual
- S. Halim, F. Halim, S. Skiena y M. Revilla. Competitive Programming. Capítulo 1, sobre el formato de entrada y salida de los problemas tipo juez.
- T. H. Cormen, C. E. Leiserson, R. L. Rivest y C. Stein. Introduction to
Algorithms, 4.ª ed., MIT Press, 2022. Secciones 2.2 y 3.1, para el análisis que
hace falta cuando el veredicto es
TIMELIMIT.