Added images

README-en.md

@@ -1 +1,168 @@
-![](titlepage.png)
+#Repetition Structures - Game of sticks
+
+![main1.png](images/main1.png)
+![main2.png](images/main2.png)
+![main3.png](images/main3.png)
+
+One of the advantages of using computer programs is that we can easily implement repetitive tasks. Structures such as the `for`, `while`, and `do-while` allow us to repeat a block of instructions as many times as needed. These structures are also known as *repetition structures*. In today’s laboratory experience you will practice the use of loops to implement a game of sticks in C++.
+
+##Objectives:
+
+Design algorithms to realize a task.
+Translate an algorithm into pseudocode.
+Implement a complete program.
+Practice the use of repetition structures.
+
+This laboratory experience is an adaptation of the exercise found in:
+http://nifty.stanford.edu/2014/laaksonen-vihavainen-game-of-sticks/handout.html.
+
+##Pre-Lab
+
+Before coming to the laboratory session you should have:
+
+Reviewed the basic concepts related to repetition structures.
+
+2. Studied the concepts and instructions for the laboratory session.
+
+3. Taken the Pre-Lab quiz available through the course’s Moodle portal.
+
+---
+
+---
+
+## Game of Sticks
+
+The game of sticks is played between two contestants. At the beginning of the game there is a pile of sticks on the table. In each turn, each player takes from 1 to 3 sticks from the table. The player that picks up the last stick loses the game.
+
+For example, a game of sticks could go like this:
+
+*  The game starts with 20 sticks on the table.
+* Aurora takes 3 sticks, there are 17 left.
+* Bruno takes 2 sticks, there are 15 left.
+* Aurora takes 1 stick, there are 14 left.
+* Bruno takes 3 sticks, there are 11 left.
+* Aurora takes 2 sticks, there are 9 left.
+* Bruno takes 2 sticks, there are 7 left.
+* Aurora takes 3 sticks, there are 4 left.
+* Bruno takes 1 stick, there are 3 left.
+* Aurora takes 2 sticks, there is 1 left.
+* Bruno has to take the last stick and loses the game.
+
+---
+
+---
+
+
+## Laboratory Session
+
+In today’s laboratory experience you will practice the use of loops to implement a game of sticks.
+
+### Exercise 1: Design the algorithm
+
+Design an algorithm so that two people can play the game of sticks on the computer. The algorithm should have these restrictions:
+
+At the beginning, it should ask the number of sticks there will be on the table. The range of accepted numbers is [10, 100]. If the user enters a number outside of this range, the program will continue asking.
+
+In each turn, the player will be allowed to take from 1 to 3 sticks (without exceeding the number of available sticks on the table). If the user enters a number outside of this range, the program will continue asking.
+
+When the game ends, the program should say who the winner is.
+
+**Example**
+
+```
+Welcome to the game of sticks!
+
+Enter an initial number of sticks [10,100]: 150
+Enter an initial number of sticks [10,100]: 10
+
+There are 10 sticks on the table.
+Player 1 - Enter the number of sticks to take (1-3): 4
+Player 1 - Enter the number of sticks to take (1-3): 3
+
+There are 7 sticks on the table.
+Player 2 - Enter the number of sticks to take (1-3): 3
+
+There are 4 sticks on the table.
+Player 1 - Enter the number of sticks to take (1-3): 2
+
+There are 2 sticks on the table.
+Player 2 - Enter the number of sticks to take (1-2): 3
+Player 2  - Enter the number of sticks to take (1-2): 1
+
+There is 1 stick on the table.
+Player 1 - Enter the number of sticks to take (1-1): 1
+You lose, Player 1 :-(
+```
+
+###Exercise 2: Write the pseudocode
+
+#### Instructions:
+
+1. Close the computer.
+
+2. Express the algorithm in pseudocode.
+
+3. Execute the pseudocode by hand to capture logical errors. Try it with various *extreme* cases and write the results by hand. [Here](https://docs.google.com/a/upr.edu/presentation/d/1m-lXCUTKhCZC8vTnmtAXwfxQjIKkSVhTUrcywiZsdbQ/edit?usp=sharing) you can see an example of how to hand check an algorithm.
+
+
+###Exercise 3: Implement the code
+
+#### Instructions: 
+
+1. Open the computer.
+
+2. Implement the algorithm in a C++ program.
+
+**Help**
+
+1) Use the `int` type variable to keep track of the player. At the end of each turn, change the player like this: 
+
+   ```cpp
+   player = player == 1 ? 2 : 1;
+
+   ```
+or number the players as 0 and 1 and use your mastery of the modulus operator:
+
+   ```cpp
+   player = (player + 1) % 2;
+
+   ```
+
+2) Think about the 3 commandments of repetition structures:
+
+   a. What is the loop control variable and what condition will be used to iterate the loop?
+
+   b. What value should the loop control variable be initialized to?
+
+   c. How is the loop control variable modified during each iteration?
+
+###Deliverables: 
+
+Use “Deliverables 1” in Moodle to hand in the pseudocode for the game of sticks.
+
+2. Use “Deliverables 2” in Moodle to hand in the paper where you and your partner executed the pseudocode by hand. 
+
+3. Use “Deliverables 3” in Moodle to hand in a `.cpp` file with the C++ program to play the game of sticks. The program should not have compiler errors, should be documented and function as intended. Remember to use good programming techniques, include the name of the programmers and document your program.
+
+
+
+---
+
+
+---
+
+##References
+
+[1] http://nifty.stanford.edu/2014/laaksonen-vihavainen-game-of-sticks/handout.html
+
+[2] http://www.gardengames.com/acatalog/509_Garden_Games_Giant_Pick-Up_Sticks.html
+
+[3] http://www.toves.org/books/java/ch05-while/
+
+[4] http://forum.codecall.net/topic/35425-pseudocode-tutorial-the-basics/page-2
+
+---
+
+---
+
+---

README-es.md

@@ -1 +1,174 @@
-![](./titlepage.png)
+#Estructuras de repetición - Juego de palitos
+
+![main1.png](images/main1.png)
+![main2.png](images/main2.png)
+![main3.png](images/main3.png)
+
+
+
+Una de las ventajas de utilizar programas de computadoras es que podemos realizar tareas repetitivas fácilmente. Los ciclos como `for`, `while`, y `do-while` son  estructuras de control que nos permiten repetir un conjunto de instrucciones. A estas estructuras también se les llama *estructuras de repetición*.  En la experiencia de laboratorio de hoy practicarás el uso de ciclos  para implementar el juego de "palitos" en C++.
+
+
+##Objetivos:
+
+1. Diseñar algoritmos para realizar una tarea.
+2. Traducir un algoritmo a pseudocódigo.
+3. Implementar un programa completo.
+4. Practicar el uso de estructuras de repetición.
+
+
+Esta experiencia de laboratorio es una adaptación del ejercicio en: http://nifty.stanford.edu/2014/laaksonen-vihavainen-game-of-sticks/handout.html.
+
+##Pre-Lab:
+
+Antes de llegar al laboratorio debes haber:
+
+1. Repasado los conceptos básicos relacionados a estructuras de repetición.
+
+2. Estudiado los conceptos e instrucciones para la sesión de laboratorio.
+
+3. Tomado el quiz Pre-Lab que se encuentra en Moodle.
+
+---
+
+---
+
+## Palitos (Game of Sticks)
+
+
+El juego de los palitos se juega entre dos contrincantes. Al principio del juego hay un montículo de palitos en la mesa. En cada turno, cada jugador retira de 1 a 3 palitos de la mesa. El jugador que recoge el último palito pierde el juego.
+
+Por ejemplo, un juego de palitos podría transcurrir así:
+
+* El juego comienza con 20 palitos en la mesa.
+* Aurora retira 3 palitos, faltan 17.
+* Bruno retira 2 palitos, faltan 15.
+* Aurora retira 1 palito, faltan 14.
+* Bruno retira 3 palitos, faltan 11.
+* Aurora retira 2 palitos, faltan 9.
+* Bruno retira 2 palitos, faltan 7.
+* Aurora retira 3 palitos, faltan 4.
+* Bruno retira 1 palito, faltan 3.
+* Aurora retira 2 palitos, falta 1.
+* Bruno tiene que retirar el único palito restante y pierde el juego.
+
+
+---
+
+---
+
+
+##Sesión de laboratorio:
+
+En la experiencia de laboratorio de hoy practicarás el uso de ciclos para implementar el juego de palitos.
+
+###Ejercicio 1: Diseñar el algoritmo
+
+
+Diseña un algoritmo para que dos personas puedan jugar el juego de los palitos en la computadora. El algoritmo debe respetar las siguientes restricciones:
+
+1. Al principio debe pedir el número de palitos que habrá en la mesa. El rango de números aceptados será de [10,100]. Si el usuario entra un número fuera de ese rango, el programa continuará preguntando.
+
+2. En cada jugada, se permitirá que el jugador retire de 1 a 3 palitos (sin exceder el número de palitos disponibles en la mesa). Si el usuario entra un número fuera de tal rango, el programa continuará preguntando.
+
+3. Al finalizar el juego, el programa debe informar quién fue el ganador.
+
+**Ejemplo:**
+
+```
+¡Bienvenidos al juego de palitos!
+
+Entre el numero inicial de palitos [10,100]: 150
+Entre el numero inicial de palitos [10,100]: 10
+
+Hay 10 palitos en la mesa.
+Jugador 1 - Entre el numero de palitos a retirar (1-3): 4
+Jugador 1 - Entre el numero de palitos a retirar (1-3): 3
+
+Hay 7 palitos en la mesa.
+Jugador 2 - Entre el numero de palitos a retirar (1-3): 3
+
+Hay 4 palitos en la mesa.
+Jugador 1 - Entre el numero de palitos a retirar (1-3): 2
+
+Hay 2 palitos en la mesa.
+Jugador 2 - Entre el numero de palitos a retirar (1-2): 3
+Jugador 2 - Entre el numero de palitos a retirar (1-2): 1
+
+Hay 1 palito en la mesa.
+Jugador 1 - Entre el numero de palitos a retirar (1-1): 1
+Perdiste Jugador 1 :-(
+```
+
+
+###Ejercicio 2: Escribir el pseudocódigo
+
+#### Instrucciones:
+
+0. Cierra la computadora.
+
+1. Expresa el algoritmo en pseudocódigo. 
+
+2. Ejecuta "a mano" el pseudocódigo para capturar errores lógicos. Trátalo con varios casos *extremos* y escribe sus resultados a mano. [Aquí](https://docs.google.com/a/upr.edu/presentation/d/1m-lXCUTKhCZC8vTnmtAXwfxQjIKkSVhTUrcywiZsdbQ/edit?usp=sharing) puedes ver un ejemplo de como hacer "hand-checking" a un algoritmo.
+
+
+###Ejercicio 3: Implementar el código
+
+#### Instrucciones:
+
+0. Abre la computadora.
+
+1. Implementa el algoritmo en un programa en C++.
+
+**Ayudas:**
+
+1. Utiliza una variable de tipo `int` para llevar cuenta del jugador. Al final de cada turno, intercambia el jugador asi:
+
+    ```cpp
+    jugador = jugador == 1 ? 2 : 1;
+    ```
+
+    o enumera los jugadores como 0 y 1 y usa tu maestría en operador módulo:
+
+    ```cpp
+    jugador = (jugador + 1) % 2;
+    ```
+
+2. Piensa en los 3 mandamientos de las estructuras de repetición:
+
+    a. ¿Cuál es la variable de control del ciclo y que condición será la que mantiene el ciclo iterando? 
+
+    b. ¿A que se inicializa la variable de control del ciclo?
+    
+    c. ¿Cómo se modifica la variable de control del ciclo en cada iteración?
+
+
+###Entregas:
+
+1. Utiliza "Entrega 1" en Moodle para entregar el pseudocódigo del juego de palitos.
+
+2. Utiliza "Entrega 2" en Moodle para entregar el papel donde tu y tu pareja hicieron la ejecución "a mano" del pseudocódigo del juego de palitos.
+
+3. Utiliza "Entrega 3" en Moodle para entregar un archivo `.cpp` con el programa en C++ para jugar palitos. El programa no debe tener errores de compilación, debe estar debidamente documentado y funcionar "como se supone". Recuerda utilizar buenas prácticas de programación, incluir el nombre de los programadores y documentar tu programa.
+
+
+
+---
+
+---
+
+##Referencias
+
+[1] http://nifty.stanford.edu/2014/laaksonen-vihavainen-game-of-sticks/handout.html
+
+[2] http://www.gardengames.com/acatalog/509_Garden_Games_Giant_Pick-Up_Sticks.html
+
+[3] http://www.toves.org/books/java/ch05-while/
+
+[4] http://forum.codecall.net/topic/35425-pseudocode-tutorial-the-basics/page-2
+
+---
+
+---
+
+---