Cómo crear un mensaje de saludo en gran rubí

Aquí es cómo crear algunas letras de gran tamaño para imprimir un gran mensaje “Hola” en Ruby. Que será la construcción de cada letra de una combinación de cadenas que, cuando se imprime, forman la forma de una gran letra.

Video: Mira el increíble regalo que Maluma le dará a Rubí | xv de Rubi

La creación de la letra H

Comience por crear las partes de cuerda para el gran letra H:

1. Crear la primera h1 variable. Esta vez, utilice nueve caracteres para el tamaño total de la cadena. En este paso, habrá siete espacios entre los dos de H:

   2.2.2: 015 gt; h1 = "S.S"= Gt; "S.S"

2. crear el h2 y h3 variables, que son idénticos a Paso 1:

   2.2.2: 017 gt; h2 = "S.S"= Gt; "S.S"2.2.2: 018 gt; h3 = "S.S"= Gt; "S.S"

3. Compruebe que ninguna de sus variables son del tamaño adecuado mediante el uso del objeto de cadena longitud método para imprimir el número de caracteres:

   2.2.2: 019 gt; h3.length = gt; 9

4. Crear la variable h4, que es la mitad de la letra H:

   2.2.2: 020 gt; h4 = "hhhhhhhhh"= Gt; "hhhhhhhhh"

   ¿Se dio cuenta de que se repite a sí mismo una gran cantidad de h2 y h3? La letra H es interesante porque las partes superior e inferior de la letra (al menos para la versión de capital que estamos utilizando) es el mismo.

   Los programadores dicen que las dos partes de la carta son simétrico. Se puede utilizar el hecho de que la parte superior e inferior son los mismos para ahorrar algo de trabajo.

5. Crear h5 asignándole el valor de h1, porque tienen el mismo aspecto:

   2.2.2: 021 gt; H5 = H1 = gt; "S.S"

6. Repita el paso 5 para las variables h6 y h7:

   2.2.2: 022 gt; h6 = H1 = gt; "S.S"2.2.2: 023 gt; h7 = H1 = gt; "S.S"

7. Poner todas las partes de la carta en una matriz de almacenamiento y probarlo. Utilice la variable denominada h para mantener la matriz:

2.2.2: 024 gt; h = [h1, h2, h3, h4, h5, h6, h7] = gt; ["S.S", "S.S", "S.S", "hhhhhhhhh", "S.S", "S.S", "S.S"] 2.2.2: 025 gt; pone HH HH HH hhhhhhhhhhh HH HH H = gt; nulo

La creación de la letra E

El siguiente paso es la letra E. Vamos a usar las mismas técnicas generales que acabas de usar para la H.

1. Crear la primera e1 variable. Utilizar nueve caracteres E para el tamaño total de la cadena:

   2.2.2: 026 gt; e1 = "EEEEEEEEE"= Gt; "EEEEEEEEE"

2. Cree la siguiente variable, e2. Éste es un poco complicado, ya que por la parte vertical de la letra E, es necesario asegurarse de que cuenta tanto la parte visible de la letra y el espacio en blanco:

   2.2.2: 027 gt; e2 = "mi"= Gt; "mi"

3. La letra E es bastante repetitivo y utiliza una u otra de las dos partes que ya haya creado. Utilizando la técnica de ahorro de tiempo que ha aprendido de la carta anterior, que la e3 variable de la misma como e2:

   2.2.2: 028 gt; e3 = e2 = gt; "mi"

4. La cuarta variable, e4, almacenará la parte horizontal medio de la carta. Para este proyecto, que sea la misma que la parte superior:

   2.2.2: 029 gt; e4 = e1 = gt; "EEEEEEEEE"

5. Tiempo para un poco más de espacio en blanco, así que los próximos dos variables almacenan el mismo valor que e2:

   Video: Como Hacer un Discurso: 15 Técnicas Efectivas Para Iniciar Tu Presentación | Tecnicas de Oratoria

   2.2.2: 030 gt; e5 = e2 = gt; "mi"2.2.2: 031 gt; e6 = e2 = gt; "mi"

6. Ahora, cree e7 para sostener la parte inferior de la letra:

   Video: Quinceañera Rubí llega a México como una celebridad | Al Rojo Vivo | Telemundo

   2.2.2: 032 gt; e7 = e1 = gt; "EEEEEEEEE"

7. Almacenar las variables independientes en una matriz y asignar a la variable que mi. Probarlo para asegurarse de que se vea bien:

2.2.2: 034 gt; e = [e1, e2, e3, e4, e5, e6, e7] = gt; ["EEEEEEEEE", "mi", "mi", "EEEEEEEEE", "mi", "mi", "EEEEEEEEE"] 2.2.2: 035 gt; pone eEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE = gt; nulo

La creación de la letra L

La letra L es aún más fácil, porque es realmente sólo hecho de dos piezas únicas.

1. Crear la primera variable l1 (Que es la letra minúscula L y el número uno):

   2.2.2: 036 gt; L1 = "L"= Gt; "L"

2. Casi la totalidad de la letra L está formada por el mismo patrón que lo almacenó en l1, por lo que vuelve a utilizar esa variable cuando se lo almacena en una matriz. En su lugar, vaya a la séptima pieza de la forma y crear variables L7:

   Video: 7 Mensajes Positivos de Buenos Días - Despierta cada Día como si Fuera el Mejor

   2.2.2: 037 gt; L7 = "LLLLLLLLL"= Gt; "LLLLLLLLL"

3. Ahora, crear la l array repitiendo el l1 variables seis veces. Una vez más, se termina ahorrando un montón de escribir!

   2.2.2: 038 gt; l = [L1, L1, L1, L1, L1, L1, l7] = gt; ["L", "L", "L", "L", "L", "L", "LLLLLLLLL"]

4. Prueba de la carta a asegurarse de que todo está formateado correctamente:

2.2.2: 039 gt; pone llllllllllllllll = gt; nulo

La creación de la letra O

La última gama carta que tendrá que explicar HOLA es la letra O. La forma de la letra O es similar a un círculo o un óvalo, y se puede tomar ventaja de que la simetría al crear sus piezas de letras.

1. crear variables o1 para la parte superior de la letra:

   2.2.2: 040 gt; o1 = " OOO "= Gt; " OOO "

2. Crear o2:

   2.2.2: 041 >- o2 = " O O "= Gt; " O O "

3. Crear o3:

   2.2.2: 042 gt; O3 = " O O "= Gt; " O O "

4. Variables O4 y o5 son simplemente repetir o3:

   2.2.2: 043 gt; o4 = o3 = gt; " O O "2.2.2: 044 gt; o5 = o3 = gt; " O O "

5. Variables O6 y o7 son los mismos que o2 y o1, respectivamente:

   2.2.2: 045 gt; o6 = o2 = gt; " O O "2.2.2: 046 gt; o7 = o1 = gt; " OOO "

6. Crear la matriz letra O y la prueba:

2.2.2: 047 gt; o = [o1, o2, o3, o4, o5, o6, o7] = gt; [" OOO ", " O O ", " O O ", " O O ", " O O ", " O O ", " OOO "] 2.2.2: 048 gt; pone OOOOO OO OO OO OO OOOO = gt; nulo

La combinación de las letras en una palabra

Ahora es el momento de montar HOLA. La primera cosa que viene a la mente es usar solo pone para imprimir cada matriz. pone puede tomar una secuencia de variables separadas por comas.

Intente imprimir sus cartas:

2.2.2: 049 gt; pone h, e, l, l, OH HH HH HH HH hhhhhhhhhhh HEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEELLLLLLLLLLLLLLLLLLLLLLLLLLLLLLOOOO OO OO OO OO OOOO = gt; nulo

Ese tipo de obras, pero se imprime verticalmente. Sería bueno si las letras se disponen horizontalmente para que sea fácil de leer la palabra HOLA.

Recuerde que las matrices son como cajas con compartimentos? Pues bien, resulta que se puede obtener el contenido de cualquiera de los contenidos pidiendo el número compartimiento de la siguiente manera:

2.2.2: 050 gt; h [0] = gt; "S.S"2.2.2: 051 gt; h [1] = gt; "S.S"

Aquí, usted está proporcionando el número del compartimiento entre corchetes al lado del nombre de la variable de matriz - marido, en este caso.

Siga estos pasos para obtener las letras para imprimir en horizontal:

1. Combinar las letras mediante la interpolación de cadenas para acceder a cada matriz al mismo tiempo:

   2.2.2: 053 gt; pone "# {H [0]} # {e [0]} # {l [0]} # {l [0]} # {o [0]}"H H EEEEEEEEE L Looo = gt; nulo

   Se puede ordenar de ver cómo las letras se están alineando. El problema es que si se utiliza pone en líneas separadas en el IRB, que no se parecerá a las filas de letras conectan a todos. Necesita alguna manera de repetir ese comando para cada una de las siete partes.

2. Una técnica más avanzada que va a utilizar una gran cantidad de proyectos posteriores se llama looping.

   Bucle es una manera de tener su propio código de repetición de un cierto número de veces. En Ruby, hay un método de bucle útil que se puede llamar a los números de contar hasta otro número. Prueba este código:

   2.2.2: 055 gt; 0.upto (6) do | cuentan | 2.2.2: 056 gt; pone h [count] + " " + E [count] + " " + [Count] l + " " + [Count] l + " " + O [count] 2.2.2: 057? gt; fin

   Tan pronto como se pulsa Intro después de la fin línea, usted debe ver:

   H H EEEEEEEEE L LOOOH H E L L O OH H E L L O ohhhhhhhhh EEEEEEEEE L L O OH H E L L O OH H E L L O OH H EEEEEEEEE LLLLLLLLL LLLLLLLLL OOO = gt; 0

   ¡Éxito! La primera línea, 0.upto (6) hacer | contar | comienza el bucle. Se prepara Ruby a contar a partir de cero, hasta e incluyendo seis. Como Ruby counts cada número, se coloca el número actual en la variable llamada contar. Rubí luego procede a la línea siguiente, que tiene su pone método. En el interior de la interpolación de cadenas que combina todas las partes de la letra, se pide la primera orden cero, e imprime esa fila. Luego se repite seis veces más y imprime cada parte en secuencia (un total de siete). El final fin línea le dice a Ruby que el bucle debe detenerse ahí.