Cara Membuat Mesej HELLO Besar di Ruby - dummies

Berikut ialah cara membuat beberapa huruf besar untuk mencetak mesej "Hello" yang besar di Ruby. Anda akan membina setiap huruf dari gabungan tali yang, apabila dicetak, membentuk bentuk huruf besar.

Membuat huruf H

Mula dengan membuat bahagian rentetan untuk huruf besar H:

Buat pemboleh ubah h1 yang pertama. Kali ini, gunakan sembilan aksara untuk saiz keseluruhan rentetan. Dalam langkah ini, akan ada tujuh ruang antara kedua-dua H:
```
2. 2. 2: 015> h1 = "H H" => "H H"
```

Buat pembolehubah h2 dan h3, yang sama dengan Langkah 1:

2. 2. 2: 017> h2 = "HH" => "HH" 2. 2. 2: 018> h3 = "HH" => "HH"

Periksa mana-mana pemboleh ubah anda adalah saiz yang betul dengan menggunakan kaedah panjang objek rentetan untuk mencetak bilangan aksara:
```
2. 2. 2: 019> h3. panjang => 9
```
Buat pemboleh ubah h4, yang merupakan tengah huruf H:
```
2. 2. 2: 020> h4 = "HHHHHHHHH" => "HHHHHHHHH"
```
Adakah anda perasan bahawa anda mengulangi banyak perkara untuk h2 dan h3? Huruf H menarik kerana bahagian atas dan bawah surat (sekurang-kurangnya untuk versi modal yang kami gunakan) adalah sama.

Pengaturcara mengatakan bahawa kedua-dua bahagian huruf simetris. Anda boleh menggunakan hakikat bahawa bahagian atas dan bawah adalah sama untuk menjimatkan kerja.
Buat h5 dengan memberikannya nilai h1, kerana ia kelihatan sama:
```
2. 2. 2: 021> h5 = h1 => "H H"
```

Ulangi Langkah 5 untuk pemboleh ubah h6 dan h7:

2. 2. 2: 022> h6 = h1 => "H H" 2. 2. 2: 023> h7 = h1 => "H H"

Masukkan semua bahagian huruf ke dalam array untuk penyimpanan dan uji itu. Gunakan pembolehubah bernama h untuk menahan array:

2. 2. 2: 024> h = [h1, h2, h3, h4, h5, h6, h7] => ["HH", "HH", "HH", "HHHHHHHHH", "HH", "HH" "HH"] 2. 2. 2: 025> meletakkan hHHHHHHHHHHHHHHHHHH => tidak

Membuat huruf E

Selanjutnya adalah huruf E. Anda akan menggunakan teknik umum yang sama yang anda gunakan untuk huruf H.

Buat pembolehubah e1 yang pertama. Gunakan sembilan aksara E untuk saiz keseluruhan rentetan:
```
2. 2. 2: 026> e1 = "EEEEEEEEE" => "EEEEEEEEE"
```
Buat pembolehubah seterusnya, e2. Yang satu ini agak rumit, kerana untuk bahagian menegak huruf E, anda perlu memastikan bahawa anda menyumbang kedua-dua bahagian yang terlihat dari huruf dan ruang kosong:
```
2. 2. 2: 027> e2 = "E" => "E"
```
Huruf E cukup berulang dan menggunakan satu atau yang lain dari dua bahagian yang telah anda buat. Dengan menggunakan teknik timesaving yang anda pelajari untuk huruf sebelumnya, buat pembolehubah e3 sama seperti e2:
```
2.2. 2: 028> e3 = e2 => "E"
```
Pembolehubah keempat, e4, akan menyimpan bahagian mendatar tengah surat itu. Untuk projek ini, buatlah sama dengan bahagian atas:
```
2. 2. 2: 029> e4 = e1 => "EEEEEEEEE"
```
Masa untuk lebih banyak ruang kosong, jadi buat dua pembolehubah berikut menyimpan nilai yang sama seperti e2:
```
2. 2. 2: 030> e5 = e2 => "E" 2. 2. 2: 031> e6 = e2 => "E"
```
Sekarang, buat e7 untuk memegang bahagian bawah huruf:
```
2. 2. 2: 032> e7 = e1 => "EEEEEEEEE"
```
Simpan pembolehubah berasingan dalam tatasusunan dan tentukan itu kepada pembolehubah e. Uji ia untuk memastikan ia kelihatan betul:

2. 2. 2: 034> e = [e1, e2, e3, e4, e5, e6, e7] => ["EEEEEEEEE", "E", "E", "EEEEEEEEE", "E", "E" "EEEEEEEEE"] 2. 2. 2: 035> meletakkan EEEEEEEEE EE EEEEEEEEE EE EEEEEEEEE => nil

Membuat huruf L

Huruf L lebih mudah, kerana ia hanya dibuat dari dua bahagian unik.

Buat pembolehubah pertama l1 (itu huruf kecil L dan angka untuk satu):
```
2. 2. 2: 036> l1 = "L" => "L"
```
Hampir semua huruf L terdiri daripada corak yang sama seperti yang anda simpan dalam l1, jadi anda akan menggunakan semula pembolehubah itu apabila anda menyimpannya dalam array. Sebaliknya, langkau ke bahagian ketujuh bentuk dan buat pembolehubah l7:
```
2. 2. 2: 037> l7 = "LLLLLLLLL" => "LLLLLLLLL"
```
Sekarang, buat array l dengan mengulangi pembolehubah l1 enam kali. Sekali lagi, anda akan menyimpan banyak menaip!
```
2. 2. 2: 038> l = [l1, l1, l1, l1, l1, l1, l7] => ["L", "L", "L", "L", "L", "L" "LLLLLLLLL"]
```
Uji huruf untuk memastikan semuanya diformatkan dengan betul:

2. 2. 2: 039> meletakkan l LLLLLL LLLLLLLLL => nil

Membuat huruf O

Arahan huruf terakhir yang anda perlukan untuk menguraikan HELLO adalah huruf O. Bentuk huruf O adalah serupa dengan bulatan atau bujur, dan anda boleh mengambil kesempatan daripada simetri itu apabila membuat bahagian surat anda.

Buat pembolehubah o1 untuk bahagian atas huruf:
```
2. 2. 2: 040> o1 = "OOO" => "OOO"
```
Buat o2:
```
2. 2. 2: 041> o2 = "O O" => "OO"
```
Buat o3:
```
2. 2. 2: 042> o3 = "O O" => "OO"
```

Pembolehubah o4 dan o5 hanya mengulangi o3:

2. 2. 2: 043> oO => "OO" 2. 2. 2: 044> o5 = o3 => "OO"

Pembolehubah o6 dan o7 masing-masing sama dengan o2 dan o1:

2. 2. 2: 045> o6 = o2 => "OO" 2. 2. 2: 046> o7 = o1 => "OOO"

Buat susunan dan ujian huruf O:

2. 2. 2: 047> o = [o1, o2, o3, o4, o5, o6, o7] => ["OOO", "OO", "OO", "OO", "OO", "OO" "OOO"] 2. 2. 2: 048> meletakkan OOO OOOOOOOOOO OOO => nil

Menggabungkan huruf-huruf ke dalam kata

Sekarang sudah tiba masanya untuk memasang HELLO. Perkara pertama yang perlu diingat adalah menggunakan hanya meletakkan setiap array. meletakkan boleh mengambil turutan pembolehubah yang dipisahkan oleh koma.

Cuba cetak surat anda:

2. 2. 2: 049> meletakkan h, e, l, l, o H H H H H HHHHHHHH H H H H H EEEEEEEEE E EEEEEEEEE E EEEEEEEEE L L L L L LLLLLLLLL L L L L L LLLLLLLLLL OOO O O O O O O O O OOO => nih

Itu jenis kerja, tetapi ia mencetak secara menegak.Ia akan menjadi lebih bagus jika huruf-huruf disusun secara mendatar untuk memudahkan membaca perkataan HELLO.

Ingat bahawa array adalah seperti kotak dengan petak-petak? Nah, ternyata anda boleh mendapatkan kandungan mana-mana kandungan tersebut dengan meminta nombor petak seperti ini:

2. 2. 2: 050> h [0] => "HH" 2. 2. 2: 051> h [1] => "HH"

Di sini, anda menyediakan bilangan petak dalam kurungan persegi seterusnya kepada nama pembolehubah array - h, dalam kes ini.

Ikuti langkah-langkah ini untuk mendapatkan huruf untuk mencetak secara mendatar:

Gabungkan huruf dengan menggunakan penyambungan rentetan untuk mengakses setiap array pada masa yang sama:
```
2. # 2 [0]} # {l [0]} # {o [0]} "HH EEEEEEEEE LL OOO => nih
```
Anda boleh melihat bagaimana huruf-hurufnya berbaris. Masalahnya ialah jika anda menggunakan meletakkan pada baris berasingan dalam LHDB, ia tidak akan kelihatan seperti baris huruf semua bersambung. Anda memerlukan beberapa cara untuk mengulangi arahan itu untuk setiap tujuh bahagian.
Teknik yang lebih maju yang anda akan gunakan banyak dalam projek-projek kemudian dipanggil looping.

Looping adalah cara untuk mengulangi kod anda sendiri beberapa kali. Di Ruby, terdapat kaedah penggalian berguna yang boleh anda panggil nombor untuk mengira nombor lain. Cuba kod ini:
```
2. 2. 2: 055> 0. upto (6) lakukan | count | 2. 2. 2: 056> meletakkan h [hitung] + "" + e [hitung] + "" + l [hitung] + "" + l [hitung] + "" + o [hitung] 2. 2. 2: 057? > akhir
```
Sebaik sahaja anda menekan Return atau Enter selepas garisan akhir, anda harus melihat:
```
H H EEEEEEEEE L L OOO H H E L L O O H H E L L O O HHHHHHHHH EEEEEEEEE L L O O H H E L L O L L L L L L O O H H EEEEEEEEE LLLLLLLLL LLLLLLLLL OOO => 0
```
Kejayaan! Baris pertama, 0. upto (6) lakukan | count | memulakan gelung. Ia menyediakan Ruby untuk mengira bermula pada sifar, sehingga dan termasuk enam. Oleh kerana Ruby mengira setiap nombor, ia meletakkan nombor semasa dalam pembolehubah bernombor. Ruby kemudian meneruskan ke baris seterusnya, yang mempunyai kaedah anda. Di dalam interpolasi rentetan yang menggabungkan semua bahagian surat, ia meminta zeroth terlebih dahulu, dan mencetak baris itu. Ia kemudian mengulangi enam kali dan mencetak setiap bahagian dalam urutan (sejumlah tujuh). Barisan akhir memberitahu Ruby bahawa gelung itu harus berhenti di sana.