Làm thế nào để Tạo một HELLO lớn Tin nhắn trong Ruby - núm vú

Dưới đây là cách tạo ra một số chữ cái siêu cỡ để in ra một tin nhắn "Hello" lớn trong Ruby. Bạn sẽ được xây dựng mỗi bức thư từ một sự kết hợp của dây mà, khi in ra, hình thành các hình dạng của một bức thư lớn.

Tạo chữ H

Bắt đầu bằng cách tạo các phần chuỗi cho chữ cái lớn H:

1. Tạo biến h1 đầu tiên. Lần này, sử dụng chín ký tự cho tổng kích thước của chuỗi. Trong bước này, sẽ có bảy khoảng cách giữa hai chữ H:

   2. 2. 2: 015> h1 = "H H" => "H H"
   

2. Tạo các biến h2 và h3, giống như bước 1:

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

3. Kiểm tra xem bất kỳ biến nào của bạn có đúng kích cỡ bằng cách sử dụng phương pháp chiều dài của đối tượng chuỗi để in ra số ký tự:

   2. 2. 2: 019> h3. length => 9
   

4. Tạo biến h4, nằm giữa chữ H:

   2. 2. 2: 020> h4 = "HHHHHHHHHH" => "HHHHHHHHH"
   

   Bạn có chú ý rằng bạn lặp lại nhiều cho h2 và h3? Chữ H rất thú vị vì phần trên và dưới của bức thư (ít nhất là đối với phiên bản vốn mà chúng ta đang sử dụng) cũng giống nhau.

   Các lập trình viên nói rằng hai phần của bức thư là đối xứng. Bạn có thể sử dụng thực tế là trên cùng và dưới cùng là như nhau để tiết kiệm một số công việc.

5. Tạo h5 bằng cách gán giá trị h1, bởi vì chúng trông giống nhau:

   2. 2. 2: 021> h5 = h1 => "H H"
   

6. Lặp lại bước 5 cho các biến h6 và h7:

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

7. Đặt tất cả các phần của bức thư vào một mảng để lưu trữ và kiểm tra nó. Sử dụng biến có tên h để giữ mảng:

2. 2. "HH", "HH", "HH", "HHHHHHHHH", "HH", "HH", "HH", "HH", "HH", "HH" "HH"] 2. 2. 2: 025> Đặt h HHHHHH HHHHHHHHH HHHHHh => nil

Tạo chữ E

Tiếp theo là chữ E. Bạn sẽ sử dụng những kỹ thuật chung mà bạn vừa sử dụng cho chữ H.

1. Tạo biến e1 đầu tiên. Sử dụng 9 ký tự E cho tổng kích thước của chuỗi:

   2. 2. 2: 026> e1 = "EEEEEEEEE" => "EEEEEEEEE"
   

2. Tạo biến tiếp theo, e2. Đây là một chút khó khăn, bởi vì đối với phần dọc của chữ E, bạn cần phải đảm bảo rằng bạn tính cả phần nhìn thấy của chữ cái và khoảng trống:

   2. 2. 2: 027> e2 = "E" => "E"
   

3. Chữ E khá lặp đi lặp lại và sử dụng một hoặc hai phần khác của hai phần bạn đã tạo ra. Sử dụng kỹ thuật tiết kiệm thời gian bạn đã học được cho lá thư trước đó, hãy biến e3 giống như e2:

   2.2. 2: 028> e3 = e2 => "E"
   

4. Biến số thứ tư, e4, sẽ lưu lại phần giữa của chữ. Đối với dự án này, làm cho nó giống như phần trên:

   2. 2. 2: 029> e4 = e1 => "EEEEEEEEE"
   

5. Thời gian cho một khoảng trống nhiều hơn, vì vậy hãy tạo hai biến tiếp theo giữ cùng một giá trị như e2:

   2. 2. E2 => "E" 2. 2. 2: 031> e6 = e2 => "E"
   

6. Bây giờ, tạo e7 để giữ đáy của bức thư:

   2. 2. 2: 032> e7 = e1 => "EEEEEEEEE"
   

7. Lưu trữ các biến riêng biệt trong một mảng và gán cho biến e. Kiểm tra nó để đảm bảo rằng nó có vẻ bên phải:

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

Tạo chữ L

Lá thư dễ dàng hơn bởi vì nó thực sự chỉ được làm bằng hai phần duy nhất.

1. Tạo biến đầu tiên l1 (đó là chữ thường chữ L và chữ số cho một):

   2. 2. 2: 036> l1 = "L" => "L"
   

2. Hầu như tất cả chữ L được tạo thành cùng kiểu với những gì bạn đã lưu trong l1, do đó bạn sẽ sử dụng lại biến đó khi bạn lưu nó trong một mảng. Thay vào đó, bỏ qua phần thứ bảy của hình dạng và tạo biến l7:

   2. 2. 2: 037> l7 = "LLLLLLLLL" => "LLLLLLLLL"
   

3. Bây giờ, tạo mảng l bằng cách lặp lại biến l1 sáu lần. Một lần nữa, bạn sẽ tiết kiệm được rất nhiều cách gõ!

   2. L, L, L, L, L, L, và L1, L1, L1, "LLLLLLLLL"]
   

4. Kiểm tra thư để đảm bảo mọi thứ được định dạng đúng:

2. 2. 2: 039> Đặt l LLLLLL LLLLLLLLL => nil

Tạo chữ O

Mảng chữ cuối cùng mà bạn cần để đánh vần là HELLO là chữ O. Hình dạng của chữ O tương tự như một vòng tròn hoặc hình bầu dục, và bạn có thể tận dụng được tính đối xứng đó khi tạo các phần chữ của bạn.

1. Tạo biến o1 cho đầu của bức thư:

   2. 2. 2: 040> o1 = "OOO" => "OOO"
   

2. Tạo o2:

   2. 2. 2: 041> o2 = "O O" => "O O"
   

3. Tạo o3:

   2. 2. 2: 042> o3 = "O O" => "O O"
   

4. Các biến o4 và o5 chỉ lặp đi lặp lại o3:

   2. Các biến số o6 và o7 tương ứng với o2 và o1 tương ứng:
   

5. o0 => O0 = 2. 2. 2: 045> o6 = o2 => "O O" 2. 2. 2: 046> o7 = o1 => "OOO"

   Tạo mảng ô O và kiểm tra:
   

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

Kết hợp các chữ cái thành một từ

Bây giờ là lúc để lắp ráp HELLO. Điều đầu tiên mà nói đến cái tâm là chỉ sử dụng puts để in từng mảng. đặt có thể lấy một dãy các biến được phân cách bằng dấu phẩy.

Thử in chữ cái của bạn:

2. 2. 2: 049> đặt h, e, l, l, o H H H H H H HHHHHHHHH H H H H H EEEEEEEEE E E EEEEEEEEE E E EEEEEEEEE L L L L L L LLLLLLLL L L L L L LLLLLLLLL OL OLLLLLL OO O O OO => Không

Loại công việc đó, nhưng nó in theo chiều dọc.Nó sẽ được tốt đẹp nếu các chữ cái được sắp xếp theo chiều ngang để làm cho nó dễ dàng để đọc từ HELLO.

Hãy nhớ rằng các mảng cũng giống như các hộp với khoang? Vâng, hóa ra bạn có thể nhận được nội dung của bất kỳ nội dung đó bằng cách yêu cầu số ngăn cách như sau:

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

Ở đây, bạn đang cung cấp số lượng ngăn ở các dấu ngoặc vuông tiếp theo đến tên của biến mảng - h, trong trường hợp này.

Làm theo các bước sau để có được chữ in theo chiều ngang:

Kết hợp các chữ cái bằng cách sử dụng chuỗi nội suy để truy cập vào mỗi mảng cùng một lúc:

1. 2. 2. 2: 053> đặt "# {h [0]} # {e [0]} # {l [0]} # {l [0]} # {o [0]}" HH EEEEEEEEE LL OOO => nil

   Bạn có thể sắp xếp xem các chữ cái đang xếp hàng như thế nào. Vấn đề là nếu bạn sử dụng đặt trên các dòng riêng biệt trong IRB, nó sẽ không giống như những dòng chữ tất cả kết nối. Bạn cần một số cách để lặp lại lệnh đó cho mỗi phần trong bảy phần.
   

   Một kỹ thuật tiên tiến hơn mà bạn sẽ sử dụng rất nhiều trong các dự án sau này được gọi là vòng lặp

2. . Looping là một cách để lặp lại mã của bạn một số lần nhất định. Trong Ruby, có một phương pháp vòng lặp tiện dụng mà bạn có thể gọi vào các con số để đếm đến một số khác. Hãy thử mã này:

   2. 2. 2: 055> 0. tối đa (6) số lượng | 2. 2. 2: 056> đặt h [count] + "" + e [count] + "" + l [count] + "" + l [count] + "" + o [count] 2. 2. 2: 057? > Kết thúc

   Ngay sau khi bạn nhấn Return hoặc Enter sau dòng kết thúc, bạn sẽ thấy:
   

   H H EEEEEEEEE L L O H H L L O O H H E L L O O H H H H HHHHHHH EEEEEEEEE LL O O H H EEEEEEEEE LLLLLLLLL LLLLLLLLL OOO => 0

   Thành công! Dòng đầu tiên, 0. đến (6) do | count | bắt đầu vòng lặp. Nó chuẩn bị để Ruby đếm bắt đầu từ số không, đến và bao gồm sáu. Khi Ruby đếm từng số, nó sẽ đặt số hiện tại vào biến số có tên. Ruby sau đó tiếp tục dòng tiếp theo, trong đó có phương pháp đặt của bạn. Bên trong của chuỗi interpolation rằng kết hợp tất cả các phần chữ cái, nó yêu cầu cho zeroth một trong những đầu tiên, và in ra hàng đó. Sau đó lặp lại sáu lần nữa và in từng phần theo thứ tự (tổng cộng là bảy). Kết thúc cuối cùng nói với Ruby rằng vòng lặp nên dừng lại ở đó.