[miércoles, octubre 24, 2012] Nos movemos...

Nos movemos a https://sites.google.com/site/pro012iessanandres.

[viernes, octubre 19, 2012] 101909 El adivino mejorado

Se  pide que escribas un porgrama llamado 101909elAdivinoMejorado.rb. El funcionamiento del programa será el mismo que el de "El adivino", pero en esta ocasión el adivino no debe repetir números al intentar adivinar el número que el usuario ha pensado.

[miércoles, octubre 17, 2012] 101707 Palabras encadenadas

Se pide que crees un programa llamado 101707palabrasEncadenadas.rb. El programa debe permitir al usuario jugar a las palabras encadenadas teniendo en cuenta que las dos últimas letras de una palabra deben coincidir con las dos primeras de la siguiente.

El programa debe felicitar al usuario con frases aleatorias cada vez que introduce una palabra correcta.

Si el usuario introduce una palabra repetida o que no encaje con la anterior el programa le explica por qué ha fallado, le echa la bronca y termina.

PISTA: se puede acceder a las letras individuales de una cadena de forma análoga a como se accede a los elementos de un array.

[miércoles, octubre 17, 2012] 101704 Tabla de contenidos extensible

Se pide que crees un programa llamado 101734tablaDeContenidosExtensible.rb. El programa debe pedirle al usuario un nombre de capítulo y la página del mismo y luego preguntarle si quiere introducir un nuevo capitulo. Cuando el usuario haya introducido todos los capítulos que desee, el programa debe mostrar una tabla de contenidos como la que se muestra a continuación:

                Tabla de Contenidos
Capítulo 1:  Números                        página 1
Capítulo 2:  Letras                        página 72
Capítulo 3:  Variables                    página 118

Cuando lo tengas terminado, guárdalo en tu carpeta de Dropbox y enséña como funciona al profesor.

[lunes, octubre 15, 2012] 101511 Ordenar palabras

Se pide que crees un programa llamado 100329ordenarPalabras.rb. El programa nos debe dejar escribir tantas palabras como nosotros querramos (una palabra por línea), continuando hasta que oprimamos Enter en una línea vacia) y luego nos devolverá las palabras en orden alfabetico según aparecen en el diccionario, independientemente de mayúsculas y minúsculas.

Consejo: Hay un hermoso método para arrays el cual te dará la version ordenada de una matriz. Investiga y usalo!

Cuando lo tengas terminado guardalo en tu carpeta de Dropbox y avisa al profesor para ver como funciona.

[lunes, octubre 15, 2012] Ruby :: Arrays e iteraciones

Vamos a escribir un programa el cual nos pida escribir tantas palabras como nosotros querramos (una palabra por línea), continuando hasta que oprimamos Enter en una línea vacia), el cual luego nos devolverá las palabras escritas por el usuario en orden alfabetico. OK?

Entonces... nosotros primero vamos; uh... um... hmmm... Bueno, nosotros podríamos; er... um...

Lo cierto es que, como tú, no pienso que seamos capaces de hacer esto. Si lo piensas bien necesitamos una forma de almacenar una cantidad desconocida de palabras y colocarlas en un tipo de lista. Lo que necesitamos son arrays.

Un array es simplemente una lista en su computadora. Cada posición en la lista actúa como una variable: puedes ver que objeto contiene cada posición, y también puedes conseguir que cada posición contenga un objeto diferente. Vamos a echar un vistazo a algunos arrays:

[]
[5]
['Hola', 'Adiós']
sabor = 'vainilla'           #  Esto no es una matriz, por supuesto...
[89.9, sabor, [true, false]]  #  ...pero esto sí lo es.

Entonces primero tenemos un array vacio, luego un array conteniendo un número simple, luego un array que contiene dos textos. Siguiendo, tenemos una simple asignación, luego un array conteniendo tres objetos, un flotante, un texto y otro array, el array [true, false].

Para ayudarnos a encontrar un objeto particular en un array, cada posición es dada por un índice numérico. Los programadores (y, por cierto, la mayoría de los matemáticos) comienzan contando desde cero, por lo que la primera posicion de un array es cero. Aquí es como nosotros deberíamos referenciar los objetos en un array:

Código:

names = ['Ada', 'Belle', 'Chris']
puts names
puts names[0]
puts names[1]
puts names[2]
puts names[3]  #  Este esta fuera del rango.

Resultado:

Ada
Belle
Chris
Ada
Belle
Chris

Entonces, nosotros vemos que puts names imprime cada nombre en el array names. Luego usamos puts names[0] para imprimir el "primer" objeto que contiene el array y puts names[1] para imprimir el "segundo" objeto ... Estoy seguro que esto parece confuso, pero puedes acostumbrarte a esto. Tienes que realmente solo comenzar pensando que el contador comienza en cero, y dejas de usar palabras como "primero" y "segundo"

Si tienes un conjunto de cinco cursos, no hablas acerca del "primer" curso, hablas acerca del curso cero (y en tu cabeza, estás pensando course[0]). Tú tienes cinco dedos en tu mano derecha, y sus números son 0, 1, 2, 3 y 4. Sabrás que lo has aprendido cuando comiences a usar la palabra "cero". Sí, esto es real; pregunta a cualquier programador o matemático.

Finalmente, tratamos puts names[3], solo para ver que podría suceder. ¿Estabas esperando un error? Algunas veces cuando preguntas algo, tu pregunta no tiene sentido (al menos para tu computadora); ahí es cuando obtienes un error. Algunas veces, en cambio, tu puedes preguntar algo y la respuesta es nada. ¿Qué hay en la posición tres? Nada. ¿Qué hay en names[3]? nil: es la forma Ruby de decir "nada". nil es un objeto especial que significa "no hay ningún objeto".

Si todo este divertido numerado de posiciones esta molestándote, ¡no te preocupes! También, podemos evitar esto completamente usando varios metodos para arrays, como el que sigue:

El Metodo 'each'
each nos permite hacer algo (lo que queramos) a cada objeto que apunte. Asi, si queremos decir algo bueno acerca de cada lenguaje en el array de abajo, podriamos hacer esto:

Código:

lenguajes = ['Inglés', 'Alemán', 'Ruby']
lenguajes.each do |leng|
  puts '¡Me gusta ' + leng + '!'
end
puts 'Y el C?'
puts '...'

Resultado:

¡Me gusta Inglés!
¡Me gusta Alemán!
¡Me gusta Ruby!
Y el C?
...

¿Qué acaba de ocurrir? Bueno, está permitido ir pasando por cada objeto del array sin utilizar ningun número. Traducido al español diriamos que: para cada (each) objeto en el array lenguajes, haz que la variable leng contenga dicho objeto y entonces haz (do) todo lo que te digo, hasta que llegues al end. (Como ya sabes, C es otro lenguaje de programación que es mucho mas difícil de aprender que Ruby; por lo general, un programa hecho en C será muchas veces más extenso que un programa en Ruby que haga la misma funcionalidad)

Estarás pensando para ti mismo, "Esto es un montón de bucles como los que hemos aprendido antes". Sí, esto es similar. Una diferencia importante es que el método each es solo eso: un método. while y end; tal como do, if, else, y todas las otras "palabras" no lo son. Ellos son una parte fundamental del lenguaje Ruby, tal como '=' y los paréntesis son tipos de puntuación como en español.

Pero no each; each es solo otro método de los arrays (como to_s era un método de los números enteros). Métodos como each que 'actuan como' bucles son a menudo llamados iteradores.

Algo para saber sobre iteradores es que estos son siempre seguidos por do...end. while e if nunca tuvieron un do cerca de ellos; nosotros solo usamos do con iteradores.

Aquí hay otro pequeño iterador, pero esto no es un método para un array... es un método para entero!

Código:

3.times do
  puts 'Hip-Hip-Hooray!'
end

Resultado:

Hip-Hip-Hooray!
Hip-Hip-Hooray!
Hip-Hip-Hooray!

Mas métodos para arrays
Entonces hemos aprendido sobre each, pero hay muchos métodos más... al menos muchos métodos para arrays. De hecho, algunos de ellos (como length, reverse, +, y *) trabajan igual que lo hacen para textos, excepto que ellos operan sobre las posiciones de una matriz y no sobre las letras de un texto. Otros, como last y join, son específicos de arraus. Y además hay otros, como push y pop, que en realidad cambian el array. Y así como con métodos para textos, no tienes que recordar todos, puedes recurrir a buscar sobre ellos consultando información en Internet.

Primero, vamos a echar un vistazo a to_s y join. join trabaja tal como to_s lo hace, excepto que este agrega un texto entre los objetos de la matriz. Vamos a mirar un poco:

Código:

alimentos = ['artichoke', 'brioche', 'caramel']
puts alimentos
puts '...'
puts alimentos.to_s
puts '...'
puts alimentos.join(', ')
puts '...'
puts alimentos.join('  :)  ') + '  8)'
200.times do
  puts []
end

Resultado:

artichoke
brioche
caramel
...
["artichoke", "brioche", "caramel"]
...
artichoke, brioche, caramel
...
artichoke  :)  brioche  :)  caramel  8)

Como puedes ver, puts trata el array diferente a otros objetos: solo llama puts sobre cada uno de los objetos en la matriz. Esto es porque puts con un array vacío 200 veces no hace nada; el array no apunta a nada; entonces no hay nada para puts. (Hacer nada 200 veces continúa siendo hacer nada)

Trata de usar puts en una matriz conteniendo otras matrices; ¿hace lo que esperabas que hiciera?

Ahora vamos a echar un vistazo a push, pop, y last. Los métodos push y pop son una suerte de métodos opuestos como lo son + y -. push agrega un objeto al final del array, y pop quita el último objeto del array (y te dice que objeto es). last es similar a pop en el sentido que te indica que hay al final del array, excepto que este deja la matriz como estaba. push y pop en realidad cambian el array:

Código:

favoritos = []
favoritos.push 'lluvia de rosas'
favoritos.push 'whisky en gatitos'
puts favoritos[0]
puts favoritos.last
puts favoritos.length
puts favoritos.pop
puts favoritos
puts favoritos.length

Resultado:

lluvia de rosas
whisky en gatitos
2
whisky en gatitos
lluvia de rosas
1

[miércoles, octubre 10, 2012] 101005 El adivino

Se pide que crees un programa llamado 101005elAdivino.rb. El programa debe presentarse como el mejor adivino de todos los tiempos y explicar al usuario que debe pensar en su cabeza en un número del 0 al 10.

Luego deberá ir mostrando números y pidiéndo al usuario que le diga si ha acertado o no el número que este había pensado. Si no lo acierta, el programa debe pedirle paciencia al usuario y a continuación debe mostrar otro número. Si lo acierta, el programa debe felicitarse a si mismo por tener dotes de adivinación con una frase del tipo "Soy genial, soy adivino profesional!! Solo he necesitado 4 intentos para leer tu mente".

Cuando lo tengas terminado guárdalo en tu caperta de Dropbox y enseña al profesor cómo funciona.

[lunes, octubre 08, 2012] 100112 Años bisiestos

Escribe un programa llamado 100112anosBisiestos.rb que pregunte por un año de inicio y uno de fin, y luego muestre en una sola línea todos los años bisiestos que han ocurrido entre ellos (incluyéndo, si también han sido los años introducidos, años bisiestos) y especificando el número total de años bisiestos detectados.

Los años bisiestos son divisibles entre cuatro (como 1984 y 2004). Sin embargo, los años divisibles entre 100 no son años bisiestos (como 1800 y 1900) a menos que sean divisibles por 400 (como 1600 y 2000, los cuales fueron, de hecho, bisiestos).

Cuando lo tengas terminado, guárdalo en tu carpeta de Dropbox y enséña como funciona al profesor.

A continuación se muestra una posible ejecución del programa:

Indica año de inicio:
1800
Indica año de fin:
2005
===
Hay 50 años bisiestos: 1804-1808-1812-1816-1820-1824-1828-1832-1836-1840-1844-1848-1852-1856-1860-1864-1868-1872-1876-1880-1884-1888-1892-1896-1904-1908-1912-1916-1920-1924-1928-1932-1936-1940-1944-1948-1952-1956-1960-1964-1968-1972-1976-1980-1984-1988-1992-1996-2000-2004

Es muy probable que antes de tenerlo correctamente funcionando te de algún error al ejecutarlo. Debes hacer un comentario en esta entrada copiando y pegando el texto informativo del error y explicándo cómo lo solucionaste.

[miércoles, octubre 03, 2012] 100108 Abuela sorda mejorado

Crea un programa llamado 100108abuelaSordaMejorado.rb basado en el anterior programa. ¿Qué pasaría si la abuela no quiere que te vayas? Cuando le grites ADIOS, ella podría pretender mostrar que no te escucha. Cambia el programa previo para que tengas que gritar ADIOS tres veces seguidas. Asegúrate que tu programa funciona de tal forma que si gritas ADIOS tres veces, pero no seguidas, sigas hablando con la abuela.

Cuando lo tengas terminado, guárdalo en tu carpeta de Dropbox y enséña como funciona al profesor.

[miércoles, octubre 03, 2012] 100102 Abuela sorda

Escribe un programa llamado 100102abuelaSorda. Lo que sea que le digas a la abuela (lo que sea que escribas), ella deberá responder con "HUH?! ¡HABLA MAS FUERTE, HIJO!", a menos que le grites (escribas todo en mayúsculas). Si le gritas, ella te escuchará (o al menos creerá eso) y te gritará de vuelta "NO, ¡NO DESDE 1938!".

Para hacer el programa realmente creíble, haz que la abuela grite un año distinto cada vez; tal vez un año aleatorio entre 1930 y 1950. No podrás dejar de hablar con la abuela hasta que le grites ADIOS.

Pista: trata de pensar que partes del programa deberían suceder una y otra vez. Todas ellas deberían estar en tu bucle while.

Cuando lo tengas terminado, guárdalo en tu carpeta de Dropbox y enséña como funciona al profesor.

[miércoles, octubre 03, 2012] 100302 Empezando con los bucles

Se pide que crees un programa llamado 100302empezandoConLosBucles.rb. El programa debe realizar lo mismo que el programa cuyo código se muestra a continuación pero con la diferencia de que no debe mostar la primera línea en blanco una vez que se ejecuta:

Código:

comando = ''
while comando != 'adios'
  puts comando
  comando = gets.chomp
end
puts '¡Vuelve pronto!'

Cuando lo tengas terminado debes enseñarselo al profesor y guardarlo en tu carpeta de Dropbox.

[miércoles, octubre 03, 2012] Ruby :: Control de flujo

Ahhhh, control de flujo. Acá es donde todo empieza a encajar. A pesar de que este capítulo es más corto y más facil que el capítulo de métodos, te abrirá un mundo nuevo de posibilidades para programar.

Luego de este capítulo, seremos capaces de escribir programas realmente interactivos; previamente hemos creado programas que dicen distintas cosas dependiendo de lo que ingreses en tu teclado, pero luego de este capítulo estos también harán distintas cosas. Pero antes que podamos hacer eso, necesitamos ser capaces de comparar objectos en nuestros programas. Necesitamos...

Métodos de comparación
Avancemos rápidamente por esta sección para que podamos ir a la siguiente, Ramificaciones, donde todas las cosas geniales ocurren. Entonces, para ver si un objeto es mayor o menor que otro, usaremos los métodos > y <, así:

Código:

puts 1 > 2
puts 1 < 2

Resultado:

false
true

Sin problemas. De igual manera, podemos identificar si un objeto es mayor-o-igual-que otro o menor-o-igual-que con los métodos >= y <=

Código:

puts 5 >= 5
puts 5 <= 4

Resultado:

true
false

Finalmente, podemos ver si dos objetos son iguales o no utilizando == (que significa "¿son éstos iguales?") y != (que significa "¿son éstos diferentes?").

Es importante no confundir = con ==. = se utiliza para decirle a una variable que contenga un determinado objeto (asignación) y == se utiliza para responder la pregunta: "¿Son estos dos objetos iguales?".

Código:

puts 1 == 1
puts 2 != 1

Resultado:

true
true

Por supuesto, podemos comparar textos también. Cuando los textos se comparan, comparan su ordenamiento lexicográfico, que básicamente significa su orden en un diccionario. 'gato' aparece antes que 'perro' en el diccionario, así que:

Código:

puts 'gato' < 'perro'

Resultado:

true

Sin embargo, hay algo que tener en cuenta: las computadoras normalmente asumen que las letras mayúsculas vienen antes que las letras minúsculas.

Esto significa que pensará que 'Zoológico' aparece antes que 'ave', así que si quieres encontrar que palabra aparecería antes en un diccionario real, asegúrate de utilizar downcase (o upcase o capitalize) en ambas palabras antes de tratar de compararlas.

Un último comentario antes de revisar Ramificaciones: los métodos de comparación no nos están dando los textos 'true' o 'false' ("verdadero" y "falso" en español); nos están dando los objetos especiales true y false. (Por supuesto, true.to_s nos devuelve 'true', que es por lo que puts imprimió 'true'.)

true y false se utilizan todo el tiempo en...

Ramificaciones
Las Ramificaciones son un concepto simple, pero poderoso. De hecho, es tan simple que no necesito explicarlo, solo te lo mostraré:

Código:

puts 'Hola, ¿cual es tu nombre?'
name = gets.chomp
puts 'Hola, ' + name + '.'
if name == 'Chris'
  puts '¡Que nombre tan hermoso!'
end

El resultado en caso de que el usuario escriba Chris:

Hola, ¿cual es tu nombre?
Chris
Hola, Chris.
¡Que nombre tan hermoso!

pero si ponemos otro nombre:

Hola, ¿cual es tu nombre?
Chewbacca
Hola, Chewbacca.

Y eso es una ramificación. Si lo que viene luego del if es true (es decir, si es cierto), se ejecutará el código entre el if y el end. Y no se ejecutará si lo que viene luego del if es false (falso). Más facil imposible.

He indentado (es decir, he puesto un par de espacios más hacia la derecha) el código entre if y el end solo porque me parece que es más facil leer las ramificaciones de esa manera. Casi todos los programadores lo hacen así, sin importar el lenguaje en que estén programando. No parece ser de mucha ayuda en este ejemplo, pero cuando las cosas se vuelven complejas, es una gran diferencia. Es totalmente recomendado que así lo hagas tú también.

Varias veces nos gustaría que un programa haga alguna cosa si una expresión es true, y otra cosa si es que es false. Para eso es que existe else:

Código:

puts 'Soy un adivino. Dime tu nombre:'
name = gets.chomp
if name == 'Chris'
  puts 'Veo grandes cosas en tu futuro.'
else
  puts 'Tu futuro es... ¡Oh! ¡Mira la hora!'
  puts 'Realmente debo irme, ¡lo siento!'
end

si respondemos 'Chris':

Soy un adivino. Dime tu nombre:
Chris
Veo grandes cosas en tu futuro.

Si tratamos con un nombre diferente:

Soy un adivino. Dime tu nombre:
Ringo
Tu futuro es... ¡Oh! ¡Mira la hora!
Realmente debo irme, ¡lo siento!

Las ramificaciones son como encontrar una bifurcación en el código: ¿seguimos el camino de las personas cuyo name == 'Chris' o el camino de aquellas que no (else)?

Y como las ramas de un árbol, puedes tener ramificaciones que a su vez tengan otras ramificaciones:

Código:

puts 'Hola, y bienvenido a la clase de 7mo año.'
puts 'Me llamo Mrs. Gabbard. ¿Tú nombre es...?'
nombre = gets.chomp
if nombre == nombre.capitalize
  puts 'Por favor, toma asiento ' + nombre + '.'
else
  puts '¿' + nombre + '? Quieres decir ' + nombre.capitalize + ', ¿cierto?'
  puts '¿No sabes escribir tu propio nombre?'
  respuesta = gets.chomp
  if respuesta.downcase == 'si'
    puts '¡Hum!  Bueno, ¡siéntese!'
  else
    puts '¡SALGA DEL SALON!'
  end
end

si respondemos el nombre en minúsculas:

Hola, y bienvenido a la clase de 7mo año.
Me llamo Mrs. Gabbard. ¿Tú nombre es...?
chris
¿chris? Quieres decir Chris, ¿cierto?
¿No sabes escribir tu propio nombre?
si
¡Hum!  Bueno, ¡siéntese!

y si respodemos el nombre como debe ser:

Hola, y bienvenido a la clase de 7mo año.
Me llamo Mrs. Gabbard. ¿Tú nombre es...?
Chris
Por favor, toma asiento Chris.

Algunas veces puede ser algo confuso entender donde todos los ifs, elses, y ends van. Lo que yo hago es escribir el end al mismo tiempo que escribo el if. Así es que como se veía al principio el programa de arriba seún lo iba escribiendo:

puts 'Hola, y bienvenido a la clase de 7mo año.'
puts 'Me llamo Mrs. Gabbard. ¿Tú nombre es...?'
nombre = gets.chomp
if nombre == nombre.capitalize
else
end

Entonces lo llené con comentarios, cosas en el código que la computadora ignorará:

puts 'Hola, y bienvenido a la clase de 7mo año.'
puts 'Me llamo Mrs. Gabbard. ¿Tú nombre es...?'
nombre = gets.chomp
if nombre == nombre.capitalize
  #  Me trata como una persona normal.
else
  #  Se vuelve loca.
end

Todo lo que aparezca luego de un # se considera un comentario (a menos, claro, que ese caracter esté dentro de una cadena). Después de eso, reemplacé los comentarios con código real. Algunas personas prefieren dejar los comentarios; personalmente, pienso que un código bien escrito normalmente habla por si mismo. Solía utilizar más comentarios, pero mientras más "flúido" me volvía con Ruby menos los utiliza. Actualmente los encuentro algo distrayentes la mayor parte del tiempo. Es una opción personal; tú encontrarás tu propio estilo (siempre en evolución). Así que mi siguiente paso se veía así:

puts 'Hola, y bienvenido a la clase de 7mo año.'
puts 'Me llamo Mrs. Gabbard. ¿Tú nombre es...?'
nombre = gets.chomp
if nombre == nombre.capitalize
  puts 'Por favor, toma asiento ' + nombre + '.'
else
  puts '¿' + nombre + '? Quieres decir ' + nombre.capitalize + ', ¿cierto?'
  puts '¿No sabes escribir tu propio nombre?'
  respuesta = gets.chomp
  if respuesta.downcase == 'si'
  else
  end
end

De nuevo, escribí los if, else, y end juntos. Realmente me ayuda para saber "donde estoy" en el código. Tambien permite que el trabajo parezca más sencillo ya que me permite enfocarme en una pequeña parte, como en llenar el código entre if y el else. El otro beneficio de realizarlo de esta manera es que el computador puede entender el programa en cualquier etapa. Cualquiera de las versiones incompletas del programa que te mostrén se podrían ejecutar. No estaban finalizadas, pero eran programas funcionales. De esa manera, podría probarlo mientras lo escribo, lo que ayuda a ver como voy avanzando y donde aún necesito trabajar.


Bucles
A veces querrás que tu computadora haga la misma acción una y otra vez —después de todo se supone que en eso son buenas las computadoras—.

Cuando le dices a la computadora que siga repitiendo algo, también debes decirle cuando parar. Las computadoras nunca se aburren asi que si no le indicas cuando hacerlo nunca lo harán. Nos aseguramos que esto no pase al indicarle a la computadora que repita ciertas partes de un programe mientras (while) una cierta condición sea cierta. Ésto funciona de manera muy similar a como lo hace if:

Código:

comando = ''
while comando != 'adios'
  puts comando
  comando = gets.chomp
end
puts '¡Vuelve pronto!'

Respuesta:

¿Hola?
¿Hola?
¡Hola!
¡Hola!
Un gusto conocerlo
Un gusto conocerlo
¡Oh... que amable!
¡Oh... que amable!
adios
¡Vuelve pronto!

Y eso es un bucle. (Tal vez te has dado cuenta de la línea vacía que sale al inicio del resultado; viene de ejecutar el primer puts, antes del primer gets).

Los bucles nos permiten hacer una serie de cosas interesantes, como estoy seguro que te podrás imaginar. Sin embargo, también pueden causar problemas si cometes un error. ¿Qué pasaría si tu computadora se queda atrapado en un bucle infinito? Si piensas que eso te ha ocurrido cuando ejecutas un programa, presiona la tecla Ctrl y a la vez la C.

Antes de empezar a jugar con los bucles, aprendamos un par de cosas que nos permitirán hacer nuestro trabajo más facil.


Un poco de lógica
Echémosle un vistazo a nuestro primer programa de condicionales una vez más. ¿Qué pasaría si mi esposa llega a casa, ve el programa, lo prueba y éste no le dice que ella tiene un nombre hermoso. Yo no querría herir sus sentimientos (o dormir en el sillón) así que reescribámoslo:

Código:

puts 'Hola, ¿cual es tu nombre?'
nombre = gets.chomp
puts 'Hola, ' + nombre + '.'
if nombre == 'Chris'
  puts '¡Que nombre tan hermoso!'
else
  if nombre == 'Katy'
    puts '¡Que nombre tan hermoso!'
  end
end

Respuesta:

Hola, ¿cual es tu nombre?
Katy
Hola, Katy.
¡Que nombre tan hermoso!

Bueno, funciona... pero no es un programa muy bonito. ¿Por qué no? Bueno, la mejor regla que he aprendido de programación es la regla DRY: Don't Repeat Yourself ("No te repitas" en español). Probablemente podría escribir un libro pequeño sobre por qué es tan buena esta regla. En nuestro caso, hemos repetido la línea puts 'Que nombre tan hermoso!'. ¿Por qué es tan problemático esto? Bueno, que pasaría si cometiera un error al escribir los textos cuando reescribí el programa? ¿Que tal si hubiera querido cambiar de 'hermoso' a 'bonito' en ambas líneas?

Soy flojo, ¿recuerdas? Básicamente si quisiera que el programa haga lo mismo cuando reciba 'Chris' o 'Katy', entonces realmente debería hacer exactamente la misma cosa:

Código:

puts 'Hola, ¿cual es tu nombre?'
nombre = gets.chomp
puts 'Hola, ' + nombre + '.'
if (nombre == 'Chris' or nombre == 'Katy')
  puts '¡Que nombre tan hermoso!'
end

Respuesta:

Hola, ¿cual es tu nombre?
Katy
Hola, Katy.
¡Que nombre tan hermoso!

Mucho mejor. Para hacer que funcione, he utilizado el operador or. Los otros operadores lógicos son and y not. Siempre es una buena idea usar los paréntesis cuando trabajamos con éstos. Veamos como funcionan:

Código:

soyChris = true
soyMorado = false
meGustaLaComida = true
comoRocas = false
puts (soyChris and meGustaLaComida)
puts (meGustaLaComida and comoRocas)
puts (soyMorado and meGustaLaComida)
puts (soyMorado and comoRocas)
puts '...'
puts (soyChris or meGustaLaComida)
puts (meGustaLaComida or comoRocas)
puts (soyMorado or meGustaLaComida)
puts (soyMorado or comoRocas)
puts '...'
puts (not soyMorado)
puts (not soyChris)

Respuesta:

true
false
false
false
...
true
true
true
false
...
true
false

La única de esas sentencias que te podría confundir es el or. En español normalmente decimos "uno u otro, pero no los dos". Por ejemplo, tu mamá podría decir "Para postre puedes pedir flan o tarta". ¡Ella no quiso decir que podrías tener ambos!

Una computadora, por otro lado, usa or (o) para decir "uno u otro o los dos" (Otra manera de decirlo es "al menos una de estas debe ser cierta"). Es por eso que las computadoras son más divertidas que mamá.

[lunes, octubre 01, 2012] 092892 Dado de la suerte

Escribe un programa llamado 092892dadoSuerte que simule lanzar dos tiradas de un dado e informe al usuario del resultado de ambas, de la suma y del resultado de elevar el número PI a la mitad de dicha cantidad. El dado puede ser un hexaedro o un dodecaedro y esta decisión debe tomarla el usuario al principio de la ejecución del programa.

Cuando lo tengas terminado, guárdalo en tu carpeta de Dropbox y enseña como funciona al profesor.

[lunes, octubre 01, 2012] Ruby :: Matemáticas

No hay tantos métodos numéricos como los hay para textos (pienso que aun no los conozco a todos sin recurrir a la ayuda de documentación). Aquí, vamos a mirar el resto de los métodos aritméticos, un generador de números aleatorios, y el objeto Math, con sus métodos trigonométricos y transcendentales.

Más de aritmética
Los otros dos métodos aritméticos son ** (potencia) y % (módulo). Si quieres decir "cinco al cuadrado" en Ruby, deberías escribir algo así 5**2. También puedes usar flotantes para tus exponentes, entonces si quieres una raíz cuadrada de 5, deberías escribir 5**0.5.

Los métodos módulo te dan el sobrante después de una división por un número. Entonces, por ejemplo, si divido 7 por 3, obtengo 2 con un remanente de 1. Vamos a ver como trabaja un programa:

Código:

puts 5**2
puts 5**0.5
puts 7/3
puts 7%3
puts 365%7

Resultado:

25
2.23606797749979
2
1
1

De la última línea, aprendimos que un año (no bisiesto) tienen algún número de semanas, más un día. Entonces si tu cumpleaños fue un martes este año, el próximo año será un miércoles. También puedes usar flotantes con el método módulo (%). Básicamente, funciona de una manera lógica... pero voy a mostrar un poco mas como trabajar con esto.

Hay un último método para mencionar antes de revisar el método random: abs. Éste sólo toma el valor absoluto de un número:

Código:

puts((5-2).abs)
puts((2-5).abs)

Resultado:

3
3

Números aleatorios
Ruby viene con un lindo generador de números aleatorios. El método para obtener un número aleatorio es rand. Si invocas a rand, obtendrás un número flotante mayor o igual a 0.0 y menor a 1.0. Si le proporcionas a rand un número entero (5 por ejemplo), esto te devolverá un entero mayor o igual a 0 y menor a 5 (entonces son cinco números posibles, de 0 a 4).

Vamos a ver rand en acción.

Código:

puts rand
puts rand
puts rand
puts(rand(101))
puts(rand(101))
puts(rand(101))
puts(rand(1))
puts(rand(1))
puts(rand(1))
puts(rand(99999999999999999999999999999999999999999999999999999999999))
puts('El hombre del tiempo dijo que hay '+rand(101).to_s+'% de posibilidades de que llueva,')
puts('pero nunca debes confiar en el.')

Un posible resultado:

0.866769322351658
0.155609260113273
0.208355946789083
61
46
92
0
0
0
22982477508131860231954108773887523861600693989518495699862
El hombre del tiempo dijo que hay 47% de posibilidades de que llueva, pero nunca debes confiar en el. 

Fijate que utilicé rand(101) para obtener números entre 0 y 100, y que el rand(1) siempre devuelve 0. No entender el rango posible de retorno de valores es el error más grande que veo en gente que hace rand; aún en programadores profesionales, más aún en productos finalizados que puedes comprar. Incluso tenía un reproductor de CD que si se configuraba en "Reproducción aleatoria," reproducia todas las canciones menos la última... (me pregunto ¿qué hubiera pasado si hubiera puesto un CD con sólo una canción en ella?)

Algunas veces querrás que rand retorne el mismo random de números incluso en la misma secuencia en dos diferentes ejecuciones de tu programa. Por ejemplo, una vez estaba utilizando números generados aleatoriamente para crear un mundo al azar por un juego de computadoras. Encontré un mundo que realmente me gustó, quizás me hubiera gustado jugar de nuevo con éste o enviarlo a un amigo. Con el fin de hacer esto, necesitas configurar la "generación de éste", lo que se puede hacer con srand. Como lo siguiente:

Código:

srand 1776
puts(rand(100))
puts(rand(100))
puts(rand(100))
puts(rand(100))
puts(rand(100))
puts '...'
srand 1776
puts(rand(100))
puts(rand(100))
puts(rand(100))
puts(rand(100))
puts(rand(100))

Resultado:

24
35
36
58
70
...
24
35
36
58
70

Esto hará la misma cosa cada vez que inicies con el mismo número. Si quieres obtener diferentes números(como pasaría si nunca utilizaras srand), entonces basta usar srand 0. Esto inicializa con un número realmente raro, utilizando (además de otras cosas) la hora actual de tu computadora, hasta los milisegundos.

El Objeto Math
Finalmente, vamos a echar un vistazo al objeto Math. Vamos a verlo de lleno:

Código:

puts(Math::PI)
puts(Math::E)
puts(Math.cos(Math::PI/3))
puts(Math.tan(Math::PI/4))
puts(Math.log(Math::E**2))
puts((1 + Math.sqrt(5))/2)

Resultado:

3.14159265358979
2.71828182845905
0.5
1.0
2.0
1.61803398874989

La primera cosa de la que te habrás dado cuenta es probablemente de la notación :: pero todavía no vamos a explicar qué significa esto.

Como puedes ver, el objeto Math tiene todas las cosas que podrías esperar de una calculadora científica decente. Y como siempre, los flotantes están realmente cerca de ser la respuesta correcta.

[lunes, octubre 01, 2012] 092880 Tabla de contenidos

Escribe un programa llamado 092880tablaContenidos.rb el cual muestre una tabla de contenidos que se parezca a lo siguiente siendo el usuario el que determina el ancho de la tabla de contenidos respondiendo previamente a una pregunta del programa.

                Table of Contents              
                                               
Chapter 1:  Numbers                        page 1
Chapter 2:  Letters                       page 72
Chapter 3:  Variables                    page 118

Cuando lo tengas terminado, guárdalo en tu carpeta de Dropbox y enséña como funciona al profesor.

[viernes, septiembre 28, 2012] 092877 Jefe enojado

Escribe el programa 092877jefeEnojado.rb. Este debe preguntar de mala manera qué quieres. Cualquier cosa que consultes, el Jefe Enojado deberá devolverte la consulta de mala forma, y luego despedirte. Por ejemplo, si tu escribes Quiero un aumento, deberá contestarte PERO QUE DICES HOMBRE "¿¡¿QUIERES UN AUMENTO"?!? ¡¡ESTAS DESPEDIDO!!

Cuando lo tengas terminado, guárdalo en tu carpeta de Dropbox y enséña como funciona al profesor.

[viernes, septiembre 28, 2012] 092856 Letras en el nombre completo

Escribe un programa que calcule el número de letras que tiene el nombre y los dos apellidos del usuario que lo usa y muestre tal número por pantalla, suponiendo que cada apellido sea un apellido simple, es decir, no contenga espacios.

Guarda el programa con el nombre 092856letrasNombreCompleto.rb. Cuando lo tengas terminado, guárdalo en tu carpeta de Dropbox y enséña como funciona al profesor.

[viernes, septiembre 28, 2012] Ruby :: Métodos

Hemos visto diferentes métodos: puts, gets, etc. (¡intenta hacer una lista de todos los métodos que hemos visto hasta ahora! Hay diez de ellos, la respuesta está abajo), pero no hemos realmente hablado sobre que hacen los métodos. Sabemos que hacen, pero no lo que son.

Pero realmente, esto es lo que son: cosas que generan otras. Si los objetos (como las cadenas, los enteros o los flotantes) son los sujetos en el lenguaje Ruby, entonces los métodos son como los verbos. Y, justo como en el español, tú no puedes tener un verbo sin un sustantivo para hacer algo. Por ejemplo, tic-tac no es algo que sólo ocurre; un reloj (o algo) tiene que hacer esto. En español podemos decir: "El reloj hace tic-tac". En Ruby podemos decir clock.tick (asumiendo por supuesto que clock es un objeto Ruby). Los programadores suelen decir que estamos "invocando o llamando el método tick de clock" o también que invocamos o llamamos al "tick de clock".

Entonces, ¿has hecho la lista del primer párrafo? Bien. Bueno, estoy seguro que recordaras los métodos puts, gets, y chomp, dado que ya hablamos sobre ellos. Probablemente también recuerdas los métodos de conversión to_i, to_f, y to_s. Sin embargo, ¿has visto los otros cuatro? Porque, estos no son otros que nuestros viejos amigos para la aritmética ¡+, -, *, y /!

Así como cada verbo necesita un sustantivo, cada método necesita un objeto. Esto es generalmente fácil de ver e indicar: el objeto es el que viene justo antes de un punto, como nuestro ejemplo clock.tick, o en 101.to_s. Algunas veces, sin embargo, esto no es tan obvio; como con los métodos aritméticos. Como resulta, 5 + 5 es solo otra forma fácil de escribir 5.+ 5. Por ejemplo:

Código:

puts 'hola '.+ 'mundo'
puts (10.* 9).+ 9

Resultado:

hola mundo
99

Esto no se ve de la forma en la que nosotros comúnmente escribimos matemáticas, por lo que lo vamos a escribir siempre como ahora; sin embargo, es importante entender que realmente estas operaciones son también métodos.

Esto también nos da un profundo entendimiento de porque podemos hacer 'pig'*5 pero no podemos hacer 5*'pig': 'pig'*5 está diciendo a 'pig' que se multiplique 5 veces, pero 5*'pig' está diciendo a 5 que se multiplique 'pig' veces. 'pig' sabe como hacer 5 copias de si mismo y poner una detrás de otra; sin embargo, 5 será incapaz de hacer 'pig' copias de si mismo y sumarlos a todos juntos.

Y, por supuesto, continuaremos teniendo puts y gets para explicar. ¿Dónde están sus objetos? En español, puedes algunas veces dejar fuera el sustantivo; por ejemplo, si un villano grita "¡Muere!", el sustantivo implícito es a quien él está gritando. En Ruby, si digo puts 'ser o no ser', lo que realmente estoy diciendo es self.puts 'ser o no ser'.

Entonces ¿que es self? Ésta es una variable especial que contiene el objeto en el que estás. Todavía no sabemos si quiera como estar en un objeto, pero hasta que lo aprendamos, podemos decir que siempre vamos a estar en el gran objeto que es... ¡el programa entero! Y este objeto, el programa entero, tiene unos pocos métodos, que incluyen a puts y a gets. Lo que sucede es que no se puede en este caso usar self.loquesea directamente. Observa lo siguiente:

Código:

noPuedoCreerQueUnaVariableConNombreTanLargoContengaSoloUn3 = 3
puts noPuedoCreerQueUnaVariableConNombreTanLargoContengaSoloUn3
self.puts NoPuedoCreerQueUnaVariableConNombreTanLargoContengaSoloUn3

Resultado:

3
in `<main>': private method `puts' called for main:Object (NoMethodError)

Si no alcanzaste a comprender todo, está bien. Lo importante es que todo método es propiedad de un objeto, incluso si no tiene un punto enfrente de este. Si entiendes esto estás preparado.

Métodos imaginativos de las cadenas
Vamos a aprender unos pocos pero interesantes métodos. No tienes porque memorizar todos; puedes mirar esta pagina de nuevo si te olvidas de alguno. Yo sólo quiero mostrarte una pequeña parte de lo que se puede hacer con una cadena. De hecho, yo no recuerdo de memoria ni siquiera la mitad de los métodos para cadenas que se pueden usar; pero está bien, porque hay buenas páginas en internet que contienen todos los métodos existentes.

Realmente, tampoco quiero saber todo acerca de los métodos para cadenas; sino sería como tratar de conocer cada palabra en el diccionario. Puedo hablar español bien sin conocer cada una de las palabras del diccionario... ¿y no es ese realmente el objetivo del diccionario? ¡De hecho no tienes por qué conocer todo lo que hay en éste para decir que sabes español!

Entonces, nuestro primer método para cadenas es reverse, el cual nos da una version invertida de un texto:

Código:

var1 = 'parar'
var2 = 'subrayado'
var3 = 'Puedes pronunciar esta oración al reves?'
puts var1.reverse
puts var2.reverse
puts var3.reverse
puts var1
puts var2
puts var3

Resultado:

rarap
odayarbus
?sever la nóicaro atse raicnunorp sedeuP
parar
subrayado
Puedes pronunciar esta oración al reves?

Como puedes ver, reverse no revierte el orden de la cadena original; éste sólo hace una nueva versión de éste en orden inverso. Esto es porque var1 continua conteniendo 'parar' aún después de que invoquemos al reverse de var1.

Otro método para texto es length, el cual nos dice el número de caracteres (incluyendo espacios) que tiene una cadena:

Código:

puts 'Cuál es tu nombre completo?'
name = gets.chomp
puts '¿Sabes que hay ' + name.length + ' caracteres en tu nombre, ' + name + '?'

Resultado:

Cuál es tu nombre completo?
Christopher David Pine
#<TypeError: can't convert Fixnum into String>

¡¡Uhh!! Algo salió mal, y esto parece que ocurrió después la línea name = gets.chomp... ¿Puedes ver el problema? Fijate si puedes darte cuenta.

El problema es con length: esto te devuelve un número, pero nosotros queremos un texto. Esto es fácil, necesitamos solo agregar to_s (y cruzar nuestros dedos):

Código:

puts 'Cuál es tu nombre completo?'
name = gets.chomp
puts '¿Sabías que hay ' + name.length.to_s + ' caracteres en tu nombre, ' + name + '?'

Resultado:

Cuál es tu nombre completo?
Christopher David Pine
Sabías que hay 22 caracteres en tu nombre, Christopher David Pine

Hay que darse cuenta que este número es el número de caracteres en mi nombre, no el número de letras.

Hay también una serie de métodos para cadenas que juegan con las mayúsculas y las minúsculas: upcase cambia cada minúscula por mayúscula; swapcase cambia cada letra minúscula por mayúscula y viceversa; finalmente, capitalize es como downcase, excepto que esta cambia solo el primer carácter a mayúsculas (si es una letra).

Código:

letters = 'aAbBcCdDeE'
puts letters.upcase
puts letters.downcase
puts letters.swapcase
puts letters.capitalize
puts ' a'.capitalize
puts letters

Resultado:

AABBCCDDEE
aabbccddee
AaBbCcDdEe
Aabbccddee
 a
aAbBcCdDeE

Esto es bastante estándar. Como puedes ver desde la linea puts ' a'.capitalize, el método capitalize sólo deja en mayúsculas el primer carácter, no la primera letra. También, como hemos visto antes, en todas estas llamadas a métodos, la variable letters permanece igual. Hay algunos métodos los cuales hacen cambios al contenido de los objetos asociados, pero no los hemos visto aún, y no lo haremos por algún tiempo.

El último tipo de métodos que veremos son los de formato visual. El primero es, center, que pone espacios al comienzo y final de la cadena para hacer que la cadena tenga un cierto tamaño y el texto original permanezca centrado. Entonces si quiero centrar las lineas de un poema, debería hacer algo como esto:

Código:

lineWidth = 50
puts('Old Mother Hubbard'.center(lineWidth))
puts('Sat in her cupboard'.center(lineWidth))
puts('Eating her curds an whey,'.center(lineWidth))
puts('When along came a spider'.center(lineWidth))
puts('Which sat down beside her'.center(lineWidth))
puts('And scared her poor shoe dog away.'.center(lineWidth))

Resultado:

          Old Mother Hubbard
         Sat in her cupboard
      Eating her curds an whey,
       When along came a spider
      Which sat down beside her
  And scared her poor shoe dog away.

Ser perezoso no es siempre algo malo en programación. Por ejemplo, fíjate como guardé el ancho del poema en la variable lineWidth.Esto supone que si entonces quiero regresar más tarde y hacer el poema más ancho, solo tengo que cambiar la variable al comienzo del programa, antes que en cada línea. Con un poema muy largo, esto podría ahorrarme un montón de tiempo. Este tipo de pereza es realmente una virtud en programación.

Los otros dos métodos de formato de textos son ljust y rjust, lo cual significan justificado izquierdo y justificado derecho. Estos son similares a center, excepto que ellos rellenan los lados derecho e izquierdo respectivamente. Vamos a verlos en acción:

Código:

lineWidth = 40
str = '--> text <--'
puts str.ljust  lineWidth
puts str.center lineWidth
puts str.rjust  lineWidth
puts str.ljust(lineWidth/2) + str.rjust(lineWidth/2)

Resultado:

--> text <--
              --> text <--
                            --> text <--
--> text <--                --> text <--

[viernes, septiembre 28, 2012] 092816 Ruby :: Interacción

Escribe con un editor de textos los siguientes 2 programas. Cada vez que termines un programa debes ejecutarlo para comprobar que el funcionamiento es el esperado.

1. Escribe un programa que pregunte por el nombre y apellidos del usuario que lo utiliza. Al final, debe saludar a la persona usando su nombre completo. Guarda el programa como 09281601saludo.rb.
2. Escribe un programa que pregunte por el número favorito del usuario que lo utiliza. Haz que tu programa le sume 17 al número y entonces sugiere al usuario el resultado como un más grande y mejor número favorito. Guarda el programa como 09281602numeroFavorito.rb.

Cuando los tengas terminados, guárdalso en tu carpeta de Dropbox y enséña como funcionan al profesor.

[viernes, septiembre 28, 2012] Ruby :: Conversiones, puts, gets y chomp

Hemos observado algunos tipos de objetos diferentes hasta ahora: números y cadenas. También hemos hecho que variables contengan dichos objetos; lo siguiente que queremos hacer es complicar un poco más la cosa.

Hemos visto que si queremos que un programa imprima 25, lo siguiente no funciona, porque no podemos sumar números y cadenas:

Código:

var1 = 2
var2 = '5'

Resultado:

puts var1 + var2

Parte del problema es que tu computadora no sabe si tú estás intentando obtener 7 (2 + 5), o si estás intentando obtener '25' ('2' + '5').

Antes de que podamos sumarlos, necesitamos una forma de obtener la versión cadena de caracteres de var1 (que actualmente contiene un número), u obtener la versión en número entero de var2 (que actualmente contiene una cadena).

Conversiones
Para obtener la versión en cadena de caracteres de un objeto simplemente le agregamos .to_s al final:

Código:

var1 = 2
var2 = '5'
puts var1.to_s + var2

Resultado:

25

De forma similar, al agregar .to_i a una variable que contiene una cadena que tenga una serie de dígitos obtenemos la versión en número entero de dichos dígitos, y .to_f nos da la versión en número flotante. Veamos un poco más de cerca que es lo que estos tres métodos hacen (y no hacen):

Código:

var1 = 2
var2 = '5'
puts var1.to_s + var2
puts var1 + var2.to_i

Resultado:

25
7

Observa que aun después de que obtuvimos la versión en cadena de caracteres de var1 utilizando to_s, var1 continua conteniendo 2 y nunca a '2'. A menos que nosotros específicamente reasignemos var1 (lo que requiere el usar un signo =), ésta contendrá 2 por el resto del programa.

Ahora intentemos algunas conversiones más interesantes (y algunas extrañas):

Código:

puts '15'.to_f
puts '99.999'.to_f
puts '99.999'.to_i
puts '...'
puts '5 es mi número favorito'.to_i
puts '¿Quien te pregunto?'.to_i
puts 'Tu madre lo hizo.'.to_f
puts '...'
puts 'cadenita'.to_s
puts 3.to_i

Resultado:

15.0
99.999
99
...
5
0
0.0
...
cadenita
3

Esto probablemente te dio algunas sorpresas. El primer resultado es muy común, imprime 15.0. Después de eso, convertimos la cadena '99.999' a su versión en números flotante y entero. La conversión al flotante apareció como esperábamos, mientras que la del entero fue, como siempre, redondeado hacia abajo.

En la siguiente parte, tenemos algunos ejemplos de cadenas un poco... inusuales siendo convertidas en números. to_i ignora lo primero que no entiende y el resto de la cadena desde ese punto en adelante. Así que la primera fue convertida en 5, pero las otras, como comienzan con letras, fueron ignoradas completamente... por lo que la computadora simplemente elige cero.

Finalmente, vimos que las dos ultimas conversiones no hicieron absolutamente nada, justo como lo esperaríamos.

Otra mirada a puts
Hay algo extraño acerca de nuestro método favorito... Observa esto:

Código:

puts 20
puts 20.to_s
puts '20'

Resultado:

20
20
20

¿Por qué estos tres imprimen la misma cosa? Bueno, los últimos dos deberían hacerlo, ya que 20.to_s es '20' Pero, ¿qué hay del primero, el entero 20? Bueno, aquí está el gran secreto detrás de nuestro amigo puts: antes de que puts intente escribir un objeto, sin que nos demos cuenta usa to_s para obtener la versión en cadena de caracteres de ese objeto. De hecho, la s en puts se refiere a cadena; puts realmente significa imprimir cadena.

Esto puede no parecer muy emocionante ahora, pero hay muchos, muchos tipos de objetos en Ruby (¡hasta aprenderás a crear los tuyos propios!), y es bueno conocer que pasará si intentas usar puts en un objeto realmente raro, como una fotografía de la abuela, un archivo de música o algo. Pero eso vendrá después...

Mientras tanto, tenemos un par de métodos más para ti, y ellos te permiten escribir todo tipo de programas divertidos...

Los métodos gets y chomp
Si puts significa imprimir cadena, estoy seguro de que adivinas que significa gets. Y justo como puts siempre escupe cadenas de caracteres, gets sólo las atrapa. Y, ¿de dónde las obtiene? ¡De ti! Bueno, de tu teclado, al menos. Como las pulsaciones de tu teclado solo produce cadenas de caracteres, funciona de maravilla. gets simplemente se sienta ahí, releyendo lo que escribes hasta que presionas Enter.

Vamos a intentarlo:

Código:

puts gets

Resultado:

¿Hay eco aquí?
¿Hay eco aquí?

Claro, cualquier cosas que escribas te será simplemente repetida de regreso. Ejecuta el programa algunas veces e intenta escribir diferentes cosas.

¡Ahora podemos hace programas interactivos! En éste, escribe tu nombre y te saludará:

Código:

puts 'Hola... y, ¿cuál es tu nombre?'
nombre = gets
puts '¿Tu nombre es ' + nombre + '? ¡Qué nombre tan hermoso!'
puts 'Gusto en conocerte ' + nombre + '.   :)'

Resultado:

Hola... y, ¿cúal es tu nombre?
Chris
¿Tu nombre es Chris
? ¡Qué nombre tan hermoso!
Gusto en conocerte, Chris
.   :)

Hmmm... parece que cuando teclee las letras C, h, r, i, s, y entonces presione Enter gets tomo todas las letras de mi nombre y también el Enter! Por suerte, hay un método justo para solucionar este problema: chomp. El cual remueve cualquier Enter que esté colgando al final de tu cadena se caracteres. Intentemos el programa de nuevo, pero con chomp para ayudarnos ésta vez:

Código:

puts 'Hola... y, ¿cuál es tu nombre?'
nombre = gets.chomp
puts '¿Tu nombre es ' + nombre + '? ¡Qué nombre tan hermoso!'
puts 'Gusto en conocerte ' + nombre + '.   :)'

Resultado:

Hola... y, ¿cúal es tu nombre?
Chris
¿Tu nombre es Chris? ¡Qué nombre tan hermoso!
Gusto en conocerte, Chris.   :)

¡Mucho mejor! Nota que como la variable nombre comtiene lo que gets.chomp produjo (es decir, lo que escribe el usuario sin el Enter del final) no hace falta que usemos nombre.chomp.

[viernes, septiembre 28, 2012] Ruby :: Variables y asignación

Hasta ahora, cuando mandamos imprimir una cadena o un número, aquello que se imprime desaparece. Lo que quiero decir es, si quisiéramos imprimir algo dos veces, tendríamos que escribirlos dos veces.

Código:

puts '...puedes decirlo de nuevo...'
puts '...puedes decirlo de nuevo...'

Resultado:

...puedes decirlo de nuevo...
...puedes decirlo de nuevo...

Sería bueno que pudiéramos escribirlo sólo una vez y después conservarlo... guardarlo en algún lugar.

Bueno, podemos, por supuesto -de otra forma, ¡no lo habría mencionado!

Para almacenar una cadena en la memoria de tu computadora, necesitamos meterla en un cajón y darle un nombre a ese cajón. Los programadores llaman variables a los cajones y asignación al proceso de meter algo en ellos.

El nombre que le damos a una variable puede tener casi cualquier secuencia de caracteres y números, pero en Ruby el primer carácter debe ser una letra minúscula.

Intentemos de nuevo el último problema, pero ésta vez meteré la cadena en una variable de nombre miCadena. (Aunque podría sólo haberla llamado cdn o miPropiaPequeñaCadena o enriqueOctavo.)

Código:

miCadena = '...puedes decir eso de nuevo...'
puts miCadena
puts miCadena

Resultado:

...puedes decirlo de nuevo...
...puedes decirlo de nuevo...

Cuando intentes hacer algo a la variable miCadena, el programa lo hará a '...puedes decirlo de nuevo...' en su lugar, es decir, a la cadena que está dentro del cajón miCadena.

Aquí hay un ejemplo un poco más interesante:

Código:

nombre = 'Yehuda Katz Yukihiro Matsumoto Linus Torvals Alan Turing'
puts 'Mi nombre es ' + nombre + '.'
puts '¡Oh! ¡' + nombre + ' es un nombre realmente largo!'

Resultado:

Mi nombre es Yehuda Katz Yukihiro Matsumoto Linus Torvals Alan Turing.
¡Oh! ¡Yehuda Katz Yukihiro Matsumoto Linus Torvals Alan Turing es un nombre realmente largo!

También, así como podemos asignar algo (un número, una cadena...) a una variable, podemos luego reasignar algo diferente a esa variable. (Esto es por lo que las llamamos variables: debido a que lo que contienen puede variar.)

Código:

compositor = 'Mozart'
puts compositor + ' era “la bomba”, es sus días.'
compositor = 'Beethoven'
puts 'Pero, personalmente, yo prefiero a ' + compositor + '.'

Resultado:

Mozart era “la bomba”, es sus días.
Pero, personalmente, yo prefiero a Beethoven.

Por su puesto, las variables pueden contener cualquier clase de objeto, no solo cadenas:

Código:

var = 'sólo otra ' + 'cadena'
puts var
var = 5 * (1 + 2)
puts var

Resultado:

sólo otra cadena
15

De hecho, las variables pueden contener casi todo... excepto otras variables. ¿Qué pasa si lo intentamos?

Código:

var1 = 8
var2 = var1
puts var1
puts var2
puts '...'
var1 = 'ocho'
puts var1
puts var2

Resultado:

8
8
...
ocho
8

Primero, cuando decimos que var2 contenga a var1, en realidad lo que conseguimos es que var2 contenga lo mismo que contenía var1, es decir, un 8. Luego hicimos que var1 contuviera 'ocho', pero como var2 no estaba en realidad conteniendo a var1, var2 se quedo conteniendo un 8.

[viernes, septiembre 28, 2012] Ruby :: Cadenas

Ahora que hemos aprendido todo acerca de números, ¿qué pasa con las letras, con las palabras, o con los textos?

Nos referimos a grupos de letras en un programa como cadenas. Aquí hay algunas cadenas, una por cada línea:

'Hola.'
'Ruby la rompe.'
'5 es mi número favorito... ¿Cuál es el tuyo?'
'Snoopy dice #%^?&*@! cuando le aplastan el dedo del pie.'
'     '
''

Como puedes ver, las cadenas pueden tener puntuación, dígitos, símbolos, y espacios dentro... es decir, pueden contener más que solo palabras. Esa última cadena no tiene nada y podemos llamarla una cadena vacía.

Hemos estado usando puts para imprimir números, intentémoslo con textos:

Código:

puts 'Hola, mundo!'
puts ''
puts 'Adiós.'

Resultado:

Hola Mundo

Adiós

Eso funcionó bien. Ahora inténtalo con algún texto tuyo.

Aritmética de textos
Igual que hacer hacer aritmética con números, ¡tú puedes también hacer aritmética con cadenas! Bueno, algo así... puedes sumar textos, digamos. Intentemos sumar dos textos y ver que hace puts con eso.

Código:

puts 'Me gusta' + 'el pastel de manzana'

Resultado:

Me gustael pastel de manzana

Whoops! Me olvidé de poner un espacio entre 'Me gusta' y 'el pastel de manzana'. Los espacios no importan generalmente salvo si lo hacen dentro de los textos. (Es verdad lo que dicen: las computadoras no hacen lo que tú quieres que hagan, solo lo que tú le dices que hagan) Intentémoslo nuevamente:

Código:

puts 'Me gusta ' + 'el pastel de manzana.'
puts 'Me gusta' + ' el pastel de manzana.'

Resultado:

Me gusta el pastel de manzana
Me gusta el pastel de manzana

(Como puedes ver, no importó a que texto le agregué el espacio)

Así que puedes sumar textos, ¡pero también puedes multiplicarlos! (Por un número ...) Observa esto:

Código:

puts 'parpadeo ' * 4

Resultado:

La computadora te hace ojitos.

(Solo bromeaba, en realidad muestra esto):

parpadeo parpadeo parpadeo parpadeo

Si lo piensas, tiene todo el sentido. Después de todo, 7*3 realmente solo significa 7+7+7, así que 'moo'*3 solo significa 'moo'+'moo'+'moo'.

12 vs '12'
Antes de ir más allá, debemos asegurarnos de entender la diferencia entre números y dígitos. 12 es un número, pero '12' es un texto de dos dígitos.

Juguemos con esto un poco:

Código:

puts  12  +  12
puts '12' + '12'
puts '12  +  12'

Resultado:

24
1212
12  +  12

Y qué sucede con esto?:

Código:

puts  2  *  5
puts '2' *  5
puts '2  *  5'

Resultado:

10
22222
2  *  5

Estos ejemplos fueron bastante directos. De cualquier modo, si no tienes cuidado en cómo mezclas tus textos y tus números podrías encontrarte con...

Problemas
En este punto podrías haber probado algunas cosas que no funcionaron. Si no lo has hecho, aquí hay algunas:

Código:

puts '12' + 12
puts '2' * '5'

Resultado:

can't convert Fixnum into String (TypeError)

Hmmm... un mensaje de error. El problema es eque en realidad no puedes sumar un número a un texto, o multiplicar un texto por otro texto. No tiene más sentido que esto:

puts 'Betty' + 12
puts 'Fred' * 'John'

Algo más para tener cuidado: Puedes escribir 'pig' * 5 en un programa, dado que sólo significa 5 veces el texto 'pig' todo sumado. De cualquier modo, tú no puedes escribir 5 * 'pig', ya que eso significa 'pig' veces el número 5, lo cual es simplemente tonto.

Finalmente, ¿qué tal si quisieras imprimir '2° 57' 32"'? Podemos intentar esto:

puts '2° 57' 32"'

Bueno, eso no funcionará; yo ni siquiera intentaría ejecutarlo. La computadora pensó que habíamos terminado con la cadena al llegar después del 57. (Por eso es bueno tener un editor de textos que colorea la sintaxis por ti). Así que, ¿cómo dejamos saber a la computadora que queremos continuar con la cadena? Tenemos que escapar el apostrofo, así:

Código:

puts '2° 57\' 32"'

Resultado:

2° 57' 32"

La diagonal invertida es el carácter de escape. En otras palabras, si tienes una diagonal invertida y otro carácter, a veces este último caracter es transformado en un nuevo carácter. Sin embargo, la diagonal invertida sólo escapa los apostrofes y así misma. (Si piensas acerca de ello, los caracteres de escape siempre deben escaparse a si mismos), Aquí hay algunos pocos ejemplos en orden, creo:

Código:

puts 'diagonal invertida al final de una cadena: \\'
puts 'arriba\\abajo'
puts 'arriba\abajo'

Resultado:

diagonal invertida al final de una cadena: \
arriba\abajo
arriba\abajo

Como la diagonal invertida no escapa una 'a', pero se escapa a si misma, las dos ultimas cadenas son idénticas. No parecen lo mismo en código, pero para tu computadora realmente son lo mismo.

Tanto los números enteros como los números flotantes como las cadenas son los que llamamos objetos.

[viernes, septiembre 28, 2012] 092601 Ruby :: Numeros

Vamos ya a empezar a programar. Escribe con un editor de textos los siguientes 4 programas. Cada vez que termines un programa debes ejecutarlo para comprobar que el funcionamiento es el esperado.

Enunciado:

1. Escribe un programa que muestre por pantalla cuántas horas hay en un año y guardalo con el nombre 09260101horasAno.rb.
2. Escribe un programa que muestre por pantalla cuántos minutos hay en una década y guárdalo con el nombre 09260102minutosDecada.rb.
3. Escribe un programa que muestre por pantalla cuantos segundos de edad tiene usted y guárdalo con el nombre 09260103segundosEdad.rb.
4. Escribe un programa que muestre por pantalla los años que tengo si tengo 1031 millones de segundos de edad y guárdalo con el nombre 09260104anosSegundos.rb.

Cuando los tengas terminados, guárdalos en tu carpeta de Dropbox y enséña como funcionan al profesor.

[jueves, septiembre 27, 2012] Como enviar las actividades propuestas

Siempre que un apartado del blog empiece con un número del tipo 092856 o similar representa un ejercicio que debes realizar y enviar al profesor.

Todas las actividades deben ser entregadas usando Dropbox (http://www.dropbox.com). Debéis descargaros el programa cliente en vuestro equipo y luego crearos una cuenta en caso de no contar con ella. Luego, dentro del directorio de Dropbox debes crear una carpeta llamada idpro012_nombre donde id debes sustituirlo por tu número de ID y nombre debes sustituirlo por tu nombre sin apellidos. Dicha carpeta la debes compartir con la dirección publi.michelbayon@gmail.com.

En esta carpeta debes dejar los archivos correspondientes a cada ejercicio (sin usar subcarpetas) y asegurarte que son sincronizados correctamente (aparece un tick verde sobre ellos). Los archivos pueden modicarse tantas veces como se desee pero solo hasta la fecha límite de entrega de los ejercicios.

[miércoles, septiembre 26, 2012] Ruby :: Números

Abre tu editor de texto favorito y escribe lo siguiente:

puts 1+2

Guarda tu programa (sí, ¡eso es un programa!) como calc.rb (el .rb es lo que usualmente ponemos al final de los programas escritos con Ruby). Ahora ejecuta tu programa escribiendo ruby calc.rb en la línea de comandos. Deberías obtener un 3 en tu pantalla. ¿Lo ves?, programar no es tan difícil, ¿cierto?

Introducción a puts
¿Cómo es que funciona ese programa? Seguramente puede adivinar qué es lo que 1+2 hace; nuestro programa es básicamente lo mismo que:

puts 3

puts simplemente escribe en la pantalla lo que sea que escribamos a continuación.

Enteros y flotantes
En la mayoría de los lenguajes de programación (y Ruby no es la excepción) los números sin decimales son llamados enteros (traducción de integers en su versión en Inglés), y los números con punto decimal normalmente son llamados números de punto flotante (o llamados solo flotantes de ahora en adelante ya que proviene de su original en inglés floats).

Aquí hay algunos enteros:

5
-205
9999999999999999999999999
0

Y aquí hay algunos flotantes:

54.321
0.001
-205.3884
0.0

En la práctica, la mayoría de los programas no usan flotantes, sólo enteros. (Después de todo, nadie quiere leer 7.4 emails, o navegar 1.8 páginas, o escuchar 5.24 de sus canciones favoritas...) Los flotantes se usan más con propósitos académicos (como por ejemplo experimentos científicos) y para gráficos en 3D.

Aritmética simple
Hasta ahora, tenemos todo lo que necesita una calculadora simple. (Las calculadoras siempre usan flotantes, así que si quiere que su computadora actúe como una calculadora, también debería usar flotantes). Para suma y resta, usamos + y -, como ya lo vimos. Para la multiplicación, usamos *, y para la división usamos /. La mayoría de los teclados tienen estas teclas en el teclado numérico a la derecha. Intentemos expandir un poco nuestro programa calc.rb. Escribe lo siguiente y ejecútalo:

puts 1.0 + 2.0
puts 2.0 * 3.0
puts 5.0 - 8.0
puts 9.0 / 2.0

Esto es lo que retorna el programa:

3.0
6.0
-3.0
4.5

(Los espacios en el programa no son importantes; simplemente hacen que el código sea más fácil de leer). Bueno, eso no fue muy sorprendente. Ahora probemos con enteros:

puts 1+2
puts 2*3
puts 5-8
puts 9/2

Básicamente lo misno, ¿no?

3
6
-3
4

Uh... ¡excepto por el último! Pero cuando se hace aritmética con enteros, se obtienen enteros. Cuando su computadora no puede obtener la respuesta "correcta", siempre redondea hacia abajo. (Por supuesto, 4 es la respuesta correcta en aritmética con enteros para 9/2; simplemente tal vez no sea el resultado que esperaba).

Tal vez se pregunte para qué es útil la división entera. Bueno, digamos que va al cine, pero sólo tiene 20 euros. Imagine que se puede ver una película por 8 euros. ¿Cuántas películas puede ver allí? 20/8... 2 películas. 2.5 definitivamente no es la respuesta correcta ya que no le dejarán ver la mitad de una película o dejar que una mitad suya vea la película entera... algunas cosas simplemente no son divisibles.

¡Así que ahora experimente con algunos programas por su cuenta! Si quiere escribir expresiones más complejas, puede usar paréntesis. Por ejemplo:

Código:

puts 5 * (12-8) + -15
puts 98 + (59872 / (13*8)) * -52

Resultado:

5
-29802

[miércoles, septiembre 26, 2012] 092609 Instalación de Ruby

Para aprender Ruby, lo primero que necesitamos es descargarlo e instalarlo en nuestro ordenador. En función del sistema operativo que se utilice, el proceso de realizará de una u otra forma.

Una vez instalado Ruby, para programar necesitas ser capaz de escribir programas. Para hacer esto, tienes que usar un editor de textos. Asegúrate de guardar tus programas como solo texto, de otra forma tus programas no funcionarán.

Finalmente, necesitas acceder a la línea de comandos de tu sistema operativo. A esta última, dependiendo de la plataforma en la que trabajéis, se accede de una forma u otra.

Enunciado:
Tienes que descargar e instalar Ruby en tu equipo. Luego debes elegir un editor de textos (que este instalado o que instales tú) y comprobar que eres capaz de acceder a la línea de comandos. Una vez que hayas hecho todo lo anterior, tienes que:

• Avisar a tu profesor y demostrarle que tienes Ruby instalado.
• Escribir un comentario en esta entrada indicando la URL de la/s página/s que has utilizado para saber cómo instalar Ruby en tu equipo y el editor de textos que vas a utilizar.

[miércoles, septiembre 26, 2012] 092607 ¿Qué lenguaje aprender?

Como ya habéis comentado en una entrada anterior, existen muchísimos lenguajes diferentes en los que se pueden programar aplicaciones para los distintos sistemas operativos. La pregunta que se nos plantea entonces es: ¿qué lenguaje utilizar para aprender a programar?

Esta decisión es una decisión subjetiva, es decir, depende a quién preguntes te dará una contestación u otra.

Enunciado:
Se pide que busqueis información en Internet sobre qué lenguaje es el más indicado para aprender a programar junto con 3 motivos que justifiquen tal decisión.

[martes, septiembre 25, 2012] Listado de alumnos e IDs

A continuación puede consultarse el ID de cada alumno:

• 01 Hector ABAD
• 02 Eros ÁLVAREZ
• 03 Sergio ÁLVAREZ
• 04 Benigno BARREDO
• 05 Roberto BAYÓN
• 06 Alejandro CABALLERO
• 07 David CLARÉS
• 08 Diego FERNÁNDEZ
• 09 Marta FERNÁDEZ
• 10 Guillermo GARCÍA
• 11 Adriana GARCÍA
• 12 Laura GÓMEZ
• 13 Diego GONZÁLEZ
• 14 Alberto GONZÁLEZ
• 15 Álvaro HERNÁNDEZ
• 16 Alberto HERRANZ
• 17 Francisco HERRERAS
• 18 Patricia LÁIZ
• 19 Sergio LÓPEZ
• 20 Javier LÓPEZ
• 21 José LÓPEZ
• 22 Ángel MARTÍNEZ
• 23 Ruben PEÑA
• 24 Hector PEÑA
• 25 Rubén PONTÓN
• 26 Gabriel PRIETO
• 27 Ángel RODRÍGUEZ
• 28 Noel RODRÍGUEZ
• 29 Roberto SÁNCHEZ
• 30 Daniel VEGA
• 31 Mario VEGA
• 32 Saray VIDAL
• 33 Rubén VILLA
• 34 Jonatan VIÑUELA

[lunes, septiembre 24, 2012] 092401 Presentación de alumnos

Vamos a conocernos. No solo porque es importante saber con quién vamos a pasar 30 horas a la semana durante los próximos 10 meses. Tambien para ir perdiendo el miedo a ponernos delante de gente y tener que contar algo. El próximo año, cuando tengáis que defender el proyecto, empezareis a ver por qué es interesante saber hablar en público y, luego, trabajando, observareis que es una habilidad muy valorada en el mundo laboral.

Enunciado:
Salir a la pizarra y presentarse ante la clase. Debes contarnos tu nombre, tu email (apuntar ambos datos en la pizarra), tu lugar de residencia, tu edad si aasí lo quieres, otros estudios completados, motivos por lo que te has matriculado en este ciclo, si repites o no (y en caso de que si que impresiones tuviste el año pasado sobre este módulo), qué expectativas tienes sobre este módulo, qué te han hablado sobre él, cuáles son tus conocimientos sobre informática en general y sobre programación en particular, qué es lo que más te apasiona de las nuevas tecnologías y por qué y en qué sector del mundo de la informática desearías trabajar el día de mañana.

[lunes, septiembre 24, 2012] 092403 Plataformas y lenguajes de programación

Vamos a ir entrando en materia y vamos a empezar a prácticar la forma de aprendizaje que utilizaremos en este módulo: investigación y trabajo autónomo del alumno guiado por el profesor.

Enunciado:
Tienes que realizar un comentario habiendo iniciado sesión con tu cuenta de Google indicando una plataforma (un sistema operativo) y un lenguaje de programación con el que se puedan crear programas para dicho sistema operativo.

[lunes, septiembre 24, 2012] 092402 Cuenta en Gmail

Fecha máxima de entrega: 28 sep, viernes 23:30 horas

Utilizaremos bastante los servicios de Google en este módulo. Algunos tendréis ya cuenta, pero quiero que la dirección sea del tipo de la indicada en el enunciado. No hay nada más poco profesional que tener una cuenta del tipo mambo69@gmail.com. Bueno, si, hay una cosa: poner una dirección de ese tipo en un currículum.

Enunciado:

• Crea una cuenta en Gmail. Debe ser del tipo nombre.apellido1.apellido2@gmail.com. 
• Completa el perfil de tu cuenta incluyendo fotografía y nombre real con dos apellidos (¡nombre y apellidos se escriben la primera con mayúscula y el resto en minúsculas!).
• Envía un email al profesor presentándote y contando brevemente tus impresiones hasta ahora en el instituto.

[lunes, septiembre 24, 2012] Presentación

¡Bienvenidos al módulo de “Programación” del Ciclo de Grado Superior de Desarrollo de Aplicaciones Multiplataforma!

Objetivo del módulo: Aprender a programar.
Profesor: Miguel Bayón Alonso (miguel.bayon.alonso@gmail.com)
Programación: enlace aun no disponible.