创建一个大的HELLO消息如何在Ruby中创建一个大的HELLO消息 - 傻瓜

以下是如何创建一些超大字母以在Ruby中打印大型“Hello”消息的方法。您将构建字符串组合中的每个字母，打印出来后形成一个大字母的形状。

创建字母H

首先创建大字母的字符串部分H：

创建第一个h1变量。这一次，使用九个字符作为字符串的总大小。在这个步骤中，两个H之间将会有七个空格：
<！ --1 - >
```
2。 2. 2：015> h1 =“H H”=>“H H”
```

创建与步骤1相同的h2和h3变量：

2. 2：017> h2 =“HH”=>“HH”2. 2. 2：018> h3 =“HH”=>“HH”

检查您的变量是否正确字符串对象的长度方法来打印出其字符数：
```
2。 2. 2：019> h3。长度=> 9
```
创建h4变量，它是字母H的中间：
```
2。 2. 2：020> h4 =“HHHHHHHHH”=>“HHHHHHHHH”
```
您是否注意到您为h2和h3重复了很多？字母H很有趣，因为这封信的顶部和底部（至少对于我们使用的大写版本）是相同的。

程序员说这个字母的两个部分是对称的。您可以使用顶部和底部相同的事实来保存一些工作。
通过给h1赋值h1来创建h5，因为它们看起来相同：
```
2。 2. 2：021> h5 = h1 =>“H H”
```

对变量h6和h7重复步骤5：

2。 2. 2：022> h6 = h1 =>“H H”2. 2. 2：023> h7 = h1 =>“H H”

将字母的所有部分放入数组中存储并测试。使用名为h的变量来保存数组：

2。 h2，h2，h3，h4，h5，h6，h7] => [“HH”，“HH”，“HH”，“HHHHHHHHH”，“HH”，“HH” “HH”] 2. 2. 2：025> puts h HHHHHH HHHHHHHHH HHHHHH => nil

创建字母E

接下来是字母E.您将使用与您刚刚使用的相同的一般技术字母H.

创建第一个e1变量。使用九个E字符作为字符串的总大小：
```
2。 2. 2：026> e1 =“EEEEEEEEE”=>“EEEEEEEEE”
```
创建下一个变量e2。这一个有点棘手，因为对于字母E的垂直部分，你需要确保你说明了字母的可见部分和空白：
```
2。 2. 2：027> e2 =“E”=>“E”
```
字母E很重复，使用已经创建的两个部分中的一个或另一个。使用您学习前一个字母的省时技术，使e3变量与e2相同：
```
2。2. 2：028> e3 = e2 =>“E”
```
第四个变量e4将存储字母的中间水平部分。对于这个项目，使其与顶部相同：
```
2。 2. 2：029> e4 = e1 =>“EEEEEEEEE”
```
需要更多空白的时间，所以使下两个变量存储与e2相同的值：
```
2. 2：030> e5 = e2 =>“E”2. 2. 2：031> e6 = e2 =>“E”
```
现在创建e7来保存字母的底部：
```
2. 2：032> e7 = e1 =>“EEEEEEEEE”
```
将单独的变量存储在数组中，并将其分配给变量e。测试它以确保它看起来是正确的：

2。 2. e：e2 e3 e4 e5 e6 e7 EEEEEEEEE E E EEE EEEEE E E E EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE EEE “EEEEEEEEE”] 2. 2. 2：035>使EEEEEEEEE EE EEEEEEEEE EE EEEEEEEEE => nil

创建字母L

字母L更容易，因为它实际上只由两个独特的部分组成。

创建第一个变量l1（小写字母L和数字）：
```
2。 2. 2：036> l1 =“L”=>“L”
```
几乎所有字母L都与您在l1中存储的模式相同，因此您将在存储该变量时重用该变量在一个数组中。相反，跳到形状的第七个部分，并创建变量l7：
```
2。 2. 2：037> l7 =“LLLLLLLLL”=>“LLLLLLLLL”
```

现在，通过重复l1变量六次来创建l数组。再一次，你最终节省了很多打字！

2。 2：038> l = [l1，l1，l1，l1，l1，l1，l7] => [“L”，“L”，“L”，“L”，“L” “LLLLLLLLL”]

测试该字母以确保一切格式正确：

2。 2. 2：039> puts l LLLLLL LLLLLLLLL => nil

创建字母O

您需要拼出HELLO的最后一个字母数组是字母O.字母O的形状类似于一个圆形或椭圆形，并且在创建字母部分时可以利用这种对称性。

在字母的顶部创建变量o1：

2。 2. 2：040> o1 =“OOO”=>“OOO”

创建o2：

2。 2. 2：041> o2 =“O O”=>“O O”

创建o3：

2。 2. 2：042> o3 =“O O”=>“O O”

变量o4和o5只是重复o3：

2。 o2 = o3 o2 = o3 o2 = o3 o2 o4 o3 => oo o9变量o6和o7分别与o2和o1相同：

2。 2. 2：045> o6 = o2 =>“O O”2. 2. 2：046> o7 = o1 =>“OOO”
```
创建字母O数组并测试：
```
OO“，”OO“，”OO“，”OO“，”OO“，”OO“，”OO“，”OO“，”OO“，”OO“ “OOO”] 2. 2. 2：048> puts o OOO OOOOOOOOOO OOO => nil

将字母组合成一个单词

现在是组装HELLO的时候了。首先想到的就是使用put来打印每个数组。 puts可以采用由逗号分隔的一系列变量。

尝试打印你的信件：

2。 2：049> puts h，e，l，l，o H H H H H H HHHHHHHHH H H H H H H EEEEEEEEE E E EEEEEEEEE E E EEEEEEEEE L L L L L L LLLLLLLLL L L L L L L LLLLLLLLL OOO O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O如果这些字母是水平排列的，很容易读出“HELLO”这个词，那将会很不错。请记住，数组像盒子的隔间？那么，事实证明，你可以通过询问这样的车厢号来得到任何这些内容的内容：

2。 2. 2：050> h [0] =>“HH”2. 2. 2：051> h [1] =>“HH”

接下来在方括号中提供隔室的编号到数组变量的名字 - h，在这种情况下。

按照以下步骤获取水平打印的字母：

使用字符串插值组合字母以同时访问每个数组：

2。 2. 2：053> puts“#{h [0]}#{e [0]}#{l [0]}#{l [0]}#{o [0]} HH EEEEEEEEE LL OOO =>零

你可以看看这些字母是如何排列的。问题是，如果在IRB中使用放入分隔线，它看起来不像字母行都连接。你需要对七个部分中的每一个重复这个命令。

以后的项目中使用的更高级的技术称为
```
循环。循环是让代码重复一定次数的一种方法。在Ruby中，有一个方便的循环方法，您可以调用数字来计算另一个数字。试试这个代码：
```
2。 2. 2：055> 0. upto（6）do | count | 2. 2. 2：056> puts h [count] +“”+ e [count] +“”+ l [count] +“”+ l [count] +“”+ o [count] 2. 2. 2 ：057？ > end
在结束行后按回车键或Enter键后，您应该看到： H EEEEEEEEE L L OOO H H E L L O O H H E L L O O HHHHHHHHHHHHH EEEEEEEEE L L O O H H E L L O O H H E L L O O H H EEEEEEEEE LLLLLLLLL LLLLLLLLL OOO => 0

第一行，0. upto（6）do | count |启动循环。它准备Ruby计数从零开始，最多可以包括六个。当Ruby计算每个数字时，它将当前数字放在名为count的变量中。然后Ruby继续下一行，它有你的put方法。在组合所有字母部分的字符串插值内部，首先要求第一个字母部分，并打印该行。然后再重复六次，依次打印每个部分（总共七个）。最后的结束行告诉Ruby，循环应该停在那里。