Está en la página 1de 8

Programación: Tarea 1 – C

Versión Hacker
Universidad Adolfo Ibáñez
Marzo 25, 2016
Honestidad Académica

A partir de ahora, las tareas del curso se vuelven más difíciles y por lo tanto, es importante
aclarar el tipo de ayuda que debes y no debes pedir. El objetivo de las tareas es ayudarte a
mejorar el aprendizaje del curso y poder rendir bien en las evaluaciones. Por esa razón, son
individuales. La copia de código es una falta ética grave que daña tu propio aprendizaje y al
sistema completo del curso.

En este curso la mejor manera de describir a lo que nos referimos con honestidad
académica es “sé razonable”. El cuerpo de profesores y ayudantes del curso entiende que la
interacción con compañeros y otras personas que sepan Programación facilita el
aprendizaje. Sin embargo, existe una fina línea que divide el pedir ayuda de enviar el
trabajo hecho por otra persona.

La esencia de toda tarea que subas a webcursos.uai.cl debe ser de tu autoría. Las tareas
son individuales. Por lo tanto, no se permite que los alumnos colaboren entre ellos o con
otros para desarrollar las tareas. Sólo puedes pedir ayuda a tus compañeros u otras personas
en la medida que esa ayuda no reduzca en nada el trabajo que tu debes hacer. En
términos generales, cuando pidas ayuda, puedes mostrarle la parte de tu código con
problemas a otros pero no puedes ver el de ellos.

A continuación entregamos un listado (no exhaustivo) de las acciones que se consideran


razonables y no razonables. Si tienes dudas, por favor consulta a los profesores del curso. Si
te sorprendemos en un acto considerado no razonable, el castigo será severo y serás
derivado a la Comisión de Ética de la Universidad. Entre los castigos posibles se encuentra
la reprobación del curso completo. Si cometes un acto no razonable, pero nos informas
dentro de las 72 horas que siguen a la entrega de la tarea, el curso puede imponer castigos
locales (que pueden incluir nota mínima en esta tarea), pero no serás derivado al Comité de
Ética de la Universidad, a menos que repitas la conducta.

Acciones razonables

Conversar con otros (en Castellano u otro lenguaje natural) acerca del enunciado de los
problemas que se entregaron en la tarea
Discutir con otros el contenido entregado en el curso con el fin de entender mejor las
herramientas disponibles para resolver los problemas de la tarea
Ayudar a un compañero a identificar un error en su código mirando, compilando y
ejecutando el código en cuestión en su computador o en el tuyo
Incorporar pequeños trozos de código que encuentres en línea en tu propio código,
siempre y cuando: a) esos pequeños trozos de código no sean las soluciones al problema
que debes resolver y b) indiques (con un comentario en el código) de donde extrajiste el
trozo de código
Revisar pruebas de años anteriores y sus soluciones
Enviar o mostrar pedazos de código con problemas (escritos por tí) a alguien,
probablemente un compañero, con el fin de que esa persona te ayude a encontrar el error
Compartir en línea trozos de tu código con otros para que te ayuden a identificar el error
Buscar en internet u otras partes más información que la que te entrega el curso para
solucionar problemas técnicos (por ejemplo, instalación de un compilador), pero no para
resolver los problemas de las tareas o del proyecto final.
Diagramar las soluciones a los problemas de las tareas con otros usando lenguaje
natural, seudo-código o diagramas de flujo, pero no código en un lenguaje de
programación determinado.
Consultar a profesores y ayudantes acerca de dudas, siempre que el profesor/ayudante no
hagan el trabajo que tu debes hacer.

Acciones no razonables

Ver la solución a alguno de los problemas de la tarea antes de subir la propia a


webcursos.uai.cl
Pedirle a un compañero poder ver su solución (o parte de ella) a algunos de los
problemas de la tarea antes de subir la propia a webcursos.uai.cl
No citar (con comentarios en el código) el origen del código u algoritmos que hayas
descubierto fuera de las lecciones y material provistos por el curso e integrarlo en tu
propio trabajo, aún cuando respete las reglas aquí descritas.
Entregar o mostrar a un compañero la solución a un problema de la tarea cuando es el
compañero, y no tu, quien está teniendo problemas para resolverlo.
Pagarle u ofrecer pagarle a alguien para que te haga el trabajo (o parte de el) que debes
subir a webcursos.uai.cl como tuyo propio.
Entregar o dejar disponible en internet las soluciones a los problemas de las tareas
Buscar o pedir soluciones a los problemas de la tarea
Dividir la carga de trabajo de la tarea con otro compañero y luego combinar el trabajo
conjunto
Enviar como propio el trabajo de otra persona (probablemente, luego de modificar partes
del mismo)
Ver la solución a los problemas de otra persona para luego usarlo como base para
construir tu propia solución
1.- Agua
La cuenta del agua sube mes a mes, y uno de los factores que más contribuyen a que pagues
mucho en tu cuenta son las duchas. Por lógica, mientras más tiempo demores en ducharte,
más agua gastarás, y eso no es bueno ni para tu bolsillo ni para el planeta. Pero, ¿cuánta
agua gastas realmente al ducharte? Incluso si tienes una ducha con ahorro de agua, es
probable que consumas alrededor de 6 litros de agua por minuto (sí, ¡por minuto!). Como
sabemos, un litro equivale a 1000 cc, por lo que 6 litros serán equivalentes a 1000 x 6 =
6000 cc de agua por minuto.

Llevemos ese número a algo más gráfico, para dimensionar la magnitud de tu gasto al
ducharte. Una botella de agua que compras en el quiosco de la UAI tiene 500cc. Dado esto,
podemos decir que 1 minuto de ducha es comparable a tomarse 12 botellas de agua por
minuto. Si consideramos una ducha promedio de 10 minutos, podemos argumentar que
gastamos alrededor de 120 botellas de agua en una sola ducha. ¡Eso es mucho!

Como parte de un plan de ahorro de agua, necesitamos construir un programa en C que nos
permita tomar conciencia de la cantidad de agua que gastamos, y tu nos ayudarás.

El programa a construir deberá solicitar al usuario “Ingresa los minutos que duró tu última
ducha:”, recibir un número entero positivo y verificar que el usuario haya ingresado un
número entero positivo. De lo contrario, deberá solicitar reintento. Una vez que el usuario
ha ingresado un número entero positivo, el programa luego mostrar el siguiente mensaje
“Tu última ducha equivale a %i botellas de agua”, donde %i es el número equivalente de
botellas de agua (como un número entero) que esa ducha consumió. Un ejemplo de la
ejecución del programa se muestra a continuación:
$ ./agua
Ingrese la duración de su última ducha en minutos: no quiero
Retry: dejame pensar
Retry: -12
Ingrese la duración de su última ducha en minutos: 10
Tu ducha equivale a 60 botellas de agua
$

No es necesario que te preocupes de cosas como que el número entero sea tan grande que
se producirá overflow y cambiará a cero pero si debes verificar que el número sea un
entero positivo (nadie se ducha 0 minutos… o -10 minutos).

Tu programa deberá guardase en un archivo que se llame como tu número de RUT (sin
guión ni dígito verificador) seguido de “agua.c”. Por ejemplo, si tu RUT es 12345678-5, el
archivo deberá llamarse 12345678agua.c

2 RUN
Es muy probable que tengas un carnet de identidad chileno en tu billetera. Todo carnet de
identidad chileno tiene un Rol Único Nacional (RUN) que consta de varios dígitos, un
guión y un dígito verificador. Según el Registro Civil: “El RUN es el número
identificatorio único e irrepetible que posee todo chileno resida o no en Chile y también de
todos los extranjeros que permanezcan en Chile, de manera temporal o definitiva”
(http://www.registrocivil.cl/html/faq/Cod_Area_4/Cod_Tema_30/pregunta_155.html).

Los números del RUN corresponden a números decimales (0 a 9). Sin embargo, el dígito
verificador (DV) consta de un dígito que va del 0 al 9 o la letra K. El DV sirve para validar
el RUN y así evitar suplantaciones y engaños
(http://www.registrocivil.cl/html/faq/Cod_Area_4/Cod_Tema_30/pregunta_155.html).
El algoritmo que el Registro Civil usa para asignar el DV de un RUN es el siguiente:

Paso 1. Se multiplica cada dígito del RUN (de derecha a izquierda, sin considerar el DV)
por el dígito correspondiente de la siguiente serie numérica: 2, 3, 4, 5, 6, 7 (volviendo al
número 2, en caso que el RUN tenga más de 6 dígitos, que es lo normal hoy en día). Por
ejemplo, el RUN (sin dígito verificador) del primer ganador del concurso “La suerte de ser
chileno”, fue el 16.850.594:

RUN: 1 6 8 5 0 5 9 4
* * * * * * * *
SERIE: 3 2 7 6 5 4 3 2
———————————————————
3 12 56 30 0 20 27 8

Paso 2. Luego, se suman los resultados obtenidos en las multiplicaciones realizadas en el


paso anterior:

3 + 12 + 56 + 30 + 0 + 20 + 27 + 8 = 156

Paso 3. A la suma obtenida en el Paso 2 se le aplica el modulo 11:

156 % 11 = 2 (156 dividido por 11 es 14 y el resto es 2).

Paso 4. Al número 11 se le resta el resultado obtenido en el Paso 3. El DV es el resultado


de la resta, excepto cuando el resultado es 11 (en cuyo caso DV=0) o 10 (en cuyo caso
DV=K).

11-2= 9

Por lo tanto, el DV del RUN 16.850.594 es el 9.

Desarrolle un programa para verificar el DV de un RUN chileno. El programa deberá


solicitar por pantalla el RUN utilizando la siguiente frase: “Ingrese su RUT, incluyendo
dígito verificador, sin puntos ni guiones (si su dígito verificador es K, ingrese un 0): ”.
En caso que el dígito verificador calculado por su programa coincida con el RUN ingresado
por el usuario, en pantalla se mostrará el mensaje “El RUN ingresado es válido”. En caso
contrario, “El RUN ingresado es inválido”.

Un ejemplo de la ejecución de este programa es la siguiente:

$ ./run
Ingrese su RUT, incluyendo dígito verificador, sin puntos ni
guiones (si su dígito verificador es K, ingrese un 0): 122303274
El RUN ingresado es inválido
$
ATENCIÓN: Si el número obtenido después de la resta es 10 (Paso 4), en vez de comparar
el valor con K, deberá comparar el valor con 0 (recuerde que solicitó que se ingresara 0 en
vez de K).
HINT: En C existe el operador % para calcular el módulo de un número
(http://www.cprogramming.com/tutorial/modulus.html).

3.- Mario
Cuando estamos finalizando el primer mundo de Super Mario Brothers para Nintendo,
Mario debe saltar sobre dos mitades de pirámide hechas con bloques cuadrados. Si no lo
recuerdas (o peor aún, ¡si nunca jugaste Super Mario Brothers!) abajo podrás ver la imagen
de esa etapa.

Escribe un programa llamado “mario.c” que permita recrear las dos mitades de pirámides.
Para adaptarnos a las posibilidades gráficas del lenguaje C, reemplaza los bloques
cuadrados por el símbolo “#”. Para hacer las cosas un poco más interesantes, primero
deberás consultar al usuario por la altura deseada de ambas pirámides y comprobar que
dicha altura sea un número no negativo menor que 23. Por ejemplo, la altura de las
pirámides de la imagen de Mario es 4.
Si el usuario ingresa un número no válido (es decir, no cumple con ser un número no
negativo menor que 23), deberás pedir que vuelva a ingresar el número hasta que lo haga
correctamente. Una vez que el usuario ha ingresado un número válido, el programa deberá
dibujar la mitad izquierda de la pirámide deseada usando la función printf(). Debes
preocuparte de alinear la esquina inferior izquierda de la pirámide con la porción inferior
izquierda de la pantalla (terminal), como se muestra en el siguiente ejemplo donde el
usuario ejecuta 3 veces el programa con diferentes valores válidos de altura:

username@ide50:~/workspace/pset1 $ ./mario
altura: 8
## ##
### ###
#### ####
##### #####
###### ######
####### #######
######## ########
######### #########
username@ide50:~/workspace/pset1 $ ./mario
altura: 1
## ##
username@ide50:~/workspace/pset1 $ ./mario
altura: 3
## ##
### ###
#### ####

A continuación te mostramos un ejemplo en el que el usuario ingresa valores no válidos


para la altura de la pirámide:

username@ide50:~/workspace/pset1 $ ./mario
Altura: -2
Altura: -1
Altura: foo
Retry: bar
Retry: 2
## ##
### ###

Recuerda que el computador imprime de izquierda a derecha, de arriba hacia abajo. No


debes dibujar ni el tubo ni las nubes, ni el texto ni el resto de los objetos de la imagen, ni
siquiera a Mario. Sólo las mitades de pirámide.
Condiciones de Entrega

El código generado se deberá subir a webcursos.uai.cl a más tardar el día Viernes 1


de Abril, a las 23:55 PM. Para esta tarea, deberás subir 3 archivos cuyos nombres
serán tu RUT, sin puntos ni guiones, y el nombre corto del ejercicio. Ejemplo, el
alumno Sebastian Moreno con RUT 12.345.678-9, tiene que entregar el archivo del
ejercicio 1 (Agua) de su tarea con el nombre 12345678agua.c, el archivo del
ejercicio 2 (RUN) con el nombre 12345678run.c y el archivo del ejercicio 3 (Mario)
con el nombre 12345678mario.c. El no cumplimiento de esta norma, descontará
puntos equivalente al número de la tarea más 1 (por ejemplo, esta es la Tarea 1, por
lo tanto se descuentan 1+1= 2 puntos, pero en la tarea 5 se descontarán 5+1=6
puntos).

No se permite ningún tipo de atraso. Evite entregar a último momento, porque siempre hay
imprevistos (por ejemplo, corte de suministro de energía eléctrica, o proveedor de
internet), y esto no justifica la no entrega de la tarea. La no entrega de tarea se evalúa con
nota 1.

La copia será severamente sancionada con nota mínima. Además se procederá con los
pasos correspondientes según el código de honor de la universidad
(http://www.uai.cl/images/seciones/universidad/Codigo_de_Honor.pdf).

Los 3 problemas de la tarea se deben resolver al mismo nivel, sin mezclar niveles. Es decir,
se entregan los problemas resueltos en version normal o los 3 problemas resueltos en
versión hacker.