template.tex

\documentclass[debug,practica]{lcc}

\codigo{R-987}
\materia{Tipografía en \LaTeX}
\num{1}
\titulo{Práctica de Ejemplo}
\subtitulo{¡con subtítulo y todo!}

% Para dejar comentarios
% \def\alan{\comm{red}{Alan Turing}}

\begin{document}

\maketitle

Este es un ejemplo de una práctica. Dentro hay algunos if que pueden
encenderse para mostrar las soluciones de los ejercicios.
\guido{Por ejemplo, este es un comentario}

\begin{ejercicio}
    El siguiente código computa una aproximación a
    $\frac{1}{\sqrt{x}}$. Explique su funcionamiento.
    \begin{C}
float Q_rsqrt(float number)
{
    long i;
    float x2, y;
    const float threehalfs = 1.5F;

    x2 = number * 0.5F;
    y  = number;
    i  = * (long *) &y;                   // evil floating point bit level hacking
    i  = 0x5f3759df - (i >> 1);           // what the fuck?
    y  = * (float *) &i;
    y  = y * (threehalfs - (x2 * y * y)); // 1st iteration
    y  = y * (threehalfs - (x2 * y * y)); // 2nd iteration, this can be removed

    return y;
}
    \end{C}
    \begin{solucion}
        Ver: \url{https://www.youtube.com/watch?v=p8u_k2LIZyo}
        \begin{C}
/* Código dentro de solución */
        \end{C}
    \end{solucion}
\end{ejercicio}

\begin{ejercicioOff}[(Filósofos Comensales, Dijkstra)]
    Esto es un ejercicio oculto. Cambiar \texttt{ejercicioOff} a
    \texttt{ejercicio} para mostrarlo.
    \begin{solucion}
        Esta es la solución del ejercicio oculto.
    \end{solucion}
\end{ejercicioOff}

\begin{ejercicio}
    \label{ej1}
    Esto es un ejercicio.
    \begin{solucion}
        Acá está la solución.
    \end{solucion}
    \begin{solucion}[variante 2]
        Acá hay otra solucion.
    \end{solucion}
\end{ejercicio}

\begin{ejercicio}[(difícil)]
    Este es un ejercicio con un tag opcional.
    Se pueden agregar referencias a ejercicios anteriores: ver \Cref{ej1}.
\end{ejercicio}

\begin{ejercicio}[\unskip*]
    Este es un ejercicio con una estrella.
\end{ejercicio}

\begin{ejercicio}
    ¿Es la siguiente definición de \hask{fibs} una estructura cíclica?
    \begin{Hask}
fibs :: [Integer]
fibs = 1 : 1 : zipWith (+) fibs (tail fibs)
    \end{Hask}
\end{ejercicio}

\begin{ejercicio}
    Este ejercicio tiene un fragmento de código C.
    \begin{C}
int main()
{
    return 0;
}
    \end{C}
    Y tambien algo de codigo C inline: \cc{return (v&(v-1)) == 0;}.
\end{ejercicio}

\begin{ejercicio}
    También puede incluirse código Bash.
    \begin{Bash}
a=0
while [ $a -le 100 ]; do
    echo $a
    a=$((a+1))
done
    \end{Bash}
    O también inline: \bash{:()\{ :|:& \};:}.
\end{ejercicio}

\begin{ejercicio}
    Acá hay Python:
    \begin{Py}
def ack(m, n):
    if m == 0:
        return n+1
    elif n == 0:
        return ack (m-1, 1)
    else:
        return ack (m-1, ack (m, n-1))
    \end{Py}
\end{ejercicio}

\section{Una Sección}

Acá vienen más ejercicios:

\begin{ejercicio}
    El siguiente código Erlang implementa la función factorial.
    Explique cómo, dado que no hay ninguna función recursiva a la vista.
    \begin{Erl}
y(F) ->
	G = (fun (X) -> F (fun (Y) -> (X(X))(Y) end) end),
	G(G).

fact(N) ->
	F0 = fun (F) -> (fun (X) -> if X == 0 -> 1; true -> X * F (X-1) end end) end,
	(y(F0))(N).
    \end{Erl}
\end{ejercicio}

\begin{ejercicio}
    Convierta la siguiente función a un bucle, sin llamadas
    recursivas.
    ¡Si \texttt{gcc -O3} puede hacerlo, usted también!
    Pista: defina variables enteras \cc{m} y \cc{b} y
    mantenga de invariante que $J(n) = m \times J(n_0) + b$ donde
    $n_0$ es el valor inicial de la llamada.

    \begin{C}
int J(int n) {
    if (n == 1)
        return 1;
    else if (n&1)
        return 2*J(n/2) + 1;
    else
        return 2*J(n/2) - 1;
}
    \end{C}
    \begin{solucion}
        Ver el uso de modo math dentro del código (con opción \texttt{mathescape}).
        \begin{C}[mathescape]
int J$^{loop}$(int n) {
    /* Inv: $J(n_0) = m \times J(n) + b$ */
    int m = 1, b = 0; /* Esto trivialmente cumple el invariante. */
    while (n != 1) {
        if (n&1) {
            /* Del invariante y de la definición original de $J$,
             * tenemos:
             *  $\begin{array}{rcl}
                       J(n_0) &=& m \times J(n) + b \\
                       J(n)   &=& 2 \times J\lfloor n/2 \rfloor + 1
                \end{array}$
             * A partir de ahí podemos sacar unas cuentas y concluir:
             *    $J(n_0) = 2 \times m \times J\lfloor n/2 \rfloor + (b+m)$,
             * justificando este paso */
            b += m; m *= 2; n /= 2;
        } else {
            /* Ídem */
            b -= m; m *= 2; n/= 2;
        }
    }
    /* Dado que ahora $n=1$, por el invariante, esto es $J(n_0)$ */
    return m + b;
}
        \end{C}
    \end{solucion}
\end{ejercicio}

\begin{ejercicio}
    Acá hay código x86 (o x64...).
    \begin{x86}
str:
	.string "I = %d\n"
	.string "multi...
		 línea!"
	.globl	main

main:
	; no soy un comentario, soy un error de sintaxis!!!
	# yo sí soy un comentario
	leaq	str(%rip), %rdi
	movq	$42, %rsi
	xorq	%rax, %rax
	call	printf@PLT

	# subq	$8, %rsp
	movb	$1234, %esi
	movs	$1234, %esi
	movl	$1234, %esi
	movq	$1234, %esi
	leaq	.LC0(%rip), %rdi
	xorl	%eax, %eax
	call	printf
	xorl	%eax, %eax
	XORl	%eax, %eax # en mayúsculas también anda
	ret
    \end{x86}
\end{ejercicio}

\begin{nota}
    Esta es una nota. Para agregar una podés usar
\begin{verbatim}
\begin{nota}
    Texto de la nota
\end{nota}
\end{verbatim}
    Aunque, si en tu documento tenés muchas notas pequeñas, podrías definir el siguiente comando
\begin{verbatim}
\newcommand{\notita}[1]{\begin{nota}#1\end{nota}}
\end{verbatim}
    y usarlo como:
\begin{verbatim}
\notita{Texto de la nota}
\end{verbatim}
    solamente tené en cuenta que eso posiblemente \textbf{no} ande
    con cosas complejas dentro del cuerpo. En ese caso, usá el entorno.
\end{nota}

\begin{ejemplo}[(Una prueba calculacional à la Dijkstra)]
    Demostramos por inducción que la famosa propiedad de que
    $\left(\sum_{i=1}^n i^3\right) = \left(\sum_{i=1}^n i\right)^2$.
    El caso base ($n = 1$) es trivial. Para el paso inductivo:
    \begin{calc}
        \form{\left(\sum_{i=1}^{n+1} i\right)^2}
        \just{=}{extraer sumando}
        \form{\left((n+1) + \sum_{i=1}^n i\right)^2}
        \just{=}{binomio de Newton}
        \form{(n+1)^2 + 2(n+1)\left(\sum_{i=1}^n i\right) + \left(\sum_{i=1}^n i\right)^2}
        \just{=}{$\sum_{i=1}^n i = n(n+1)/2$}
        \form{(n+1)^2 + (n+1)n(n+1) + \left(\sum_{i=1}^n i\right)^2}
        \just{=}{H.I., expandir}
        \form{n^2 + 2n + 1 + n^3 + 2n^2 + n + \left(\sum_{i=1}^n i^3\right)}
        \just{=}{arimética}
        \form{n^3 + 3n^2 + 3n + 1 + \left(\sum_{i=1}^n i^3\right)}
        \just{=}{binomio de Newton}
        \form{(n+1)^3 + \left(\sum_{i=1}^n i^3\right)}
        \just{=}{agrupar}
        \form{\left(\sum_{i=1}^{n+1} i^3\right)}
    \end{calc}
\end{ejemplo}

\end{document}