Πώς να δημιουργήσετε ένα μεγάλο μήνυμα HELLO σε Ruby - dummies

Εδώ μπορείτε να δημιουργήσετε μερικά μεγάλα γράμματα για να εκτυπώσετε ένα μεγάλο μήνυμα "Hello" στο Ruby. Θα χτίζετε κάθε γράμμα από ένα συνδυασμό χορδών που, όταν τυπωθούν έξω, σχηματίζουν τα σχήματα ενός μεγάλου γράμματος.

Δημιουργία του γράμματος H

Ξεκινήστε δημιουργώντας τα τμήματα συμβολοσειρών για το μεγάλο γράμμα H:

Δημιουργήστε την πρώτη μεταβλητή h1. Αυτή τη φορά, χρησιμοποιήστε εννέα χαρακτήρες για το συνολικό μέγεθος της συμβολοσειράς. Σε αυτό το βήμα, θα υπάρχουν επτά διαστήματα μεταξύ των δύο Η:
```
2. 2. 2: 015> h1 = "H H" => "H H"
```
Δημιουργήστε τις μεταβλητές h2 και h3, οι οποίες είναι ίδιες με το Βήμα 1:
```
2. 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 είναι ενδιαφέρον επειδή τα επάνω και τα κάτω μέρη της επιστολής (τουλάχιστον για την πρωτεύουσα έκδοση που χρησιμοποιούμε) είναι τα ίδια.

Οι προγραμματιστές λένε ότι τα δύο μέρη του γράμματος είναι συμμετρικά . Μπορείτε να χρησιμοποιήσετε το γεγονός ότι το επάνω και το κάτω μέρος είναι το ίδιο για να αποθηκεύσετε κάποια εργασία.
Δημιουργήστε το h5, αναθέτοντας την τιμή του h1, επειδή φαίνονται τα ίδια:
```
2. 2. 2: 021> h5 = h1 => "H H"
```
Επαναλάβετε το βήμα 5 για τις μεταβλητές h6 και h7:
```
2. 2. 2: 022> h6 = h1 => "H H" 2. 2. 2: 023> h7 = h1 => H H
```
Χρησιμοποιήστε τη μεταβλητή που ονομάζεται h για να κρατήσετε τη συστοιχία:

2. 2. 2: 024> h = [h1, h2, h3, h4, h5, h6, h7] => ["HH", "HH", "HH", "HHHHHHHHH", "HH" "HH"] 2. 2. 2: 025> βάζει HHHHHH HHHHHHHHH HHHHHH => nil

Δημιουργία του γράμματος E

Επόμενο επάνω είναι το γράμμα E. Θα χρησιμοποιήσετε τις ίδιες γενικές τεχνικές που μόλις χρησιμοποιήσατε το γράμμα H.

Δημιουργήστε την πρώτη μεταβλητή e1. Χρησιμοποιήστε εννέα χαρακτήρες E για το συνολικό μέγεθος της συμβολοσειράς:
```
2. 2. 2: 026> e1 = "EEEEEEEEE" => "EEEEEEEEE"
```
Δημιουργήστε την επόμενη μεταβλητή e2. Αυτό είναι λίγο δύσκολο, επειδή για το κάθετο μέρος του γράμματος Ε, πρέπει να βεβαιωθείτε ότι έχετε υπόψη τόσο το ορατό τμήμα του γράμματος όσο και το κενό:
```
2. 2. 2: 027> e2 = "E" => "E"
```
Το γράμμα Ε είναι αρκετά επαναλαμβανόμενο και χρησιμοποιεί το ένα ή το άλλο από τα δύο μέρη που έχετε ήδη δημιουργήσει. Χρησιμοποιώντας την τεχνική εξοικονόμησης χρόνου που μάθατε για το προηγούμενο γράμμα, ορίστε τη μεταβλητή e3 ίδια με την e2:
```
2.2. 2: 028> e3 = e2 => "E"
```
Η τέταρτη μεταβλητή, e4, θα αποθηκεύσει το μεσαίο οριζόντιο τμήμα του γράμματος. Για αυτό το έργο, το κάνετε το ίδιο με το πάνω μέρος:
```
2. 2. 2: 029> e4 = e1 => "EEEEEEEEE"
```
Χρόνος για κάποιους περισσότερους κεντρικούς χαρακτήρες, ώστε οι επόμενες δύο μεταβλητές να αποθηκεύουν την ίδια τιμή με e2:
```
2. 2. 2: 030> e5 = e2 => "E" 2. 2. 2: 031> e6 = e2 => "E"
```

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

Αποθηκεύστε τις ξεχωριστές μεταβλητές σε έναν πίνακα και αντιστοιχίστε το στην μεταβλητή e. Δοκιμάστε το για να βεβαιωθείτε ότι φαίνεται σωστά:

2. 2. 2: 034> e = [e1, e2, e3, e4, e5, e6, e7] => ["EEEEEEEEE", "E", "E", "EEEEEEEEE" "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 = "LLLLLLLLLL" => "LLLLLLLLL"

Τώρα, δημιουργήστε το l πίνακα επαναλαμβάνοντας τη μεταβλητή l1 έξι φορές. Για άλλη μια φορά, καταλήγετε εξοικονομώντας πολύ δακτυλογράφηση!

2. 2. 2: 038> Ι = [11, 11, 11, 11, 11, 11, 17] => [L, L, L, L, L, "LLLLLLLLL"]

Δοκιμάστε το γράμμα για να βεβαιωθείτε ότι όλα είναι σωστά μορφοποιημένα:

2. Το γράμμα O

Ο τελευταίος πίνακας γραμμάτων που θα χρειαστεί να γράψετε HELLO είναι το γράμμα O. Το σχήμα του γράμματος 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. 2: 043> o4 = o3 => OO 2. 2. 2: 044> o5 = o3 => OO
```
Οι μεταβλητές o6 και o7 είναι οι ίδιες με τις o2 και o1, 2. 2. 2: 045> o6 = o2 => "O O" 2. 2. 2: 046> o7 = o1 => "OOO"
```
2. 2: 047> o = [o1, o2, o3, o4, o5, o6, o7] => ["OOO", "OO", "OO", "OO" "OOO"] 2. 2. 2: 048> puts o OOO OOOOOOOOOOOO OOO => μηδέν
```

Συνδυάζοντας τα γράμματα σε μια λέξη

Τώρα ήρθε η ώρα να συναρμολογήσετε την HELLO. Το πρώτο πράγμα που έρχεται στο μυαλό είναι να χρησιμοποιήσετε απλώς βάζει για να εκτυπώσετε κάθε πίνακα. μπορεί να πάρει μια ακολουθία μεταβλητών που χωρίζονται με κόμματα.

Δοκιμάστε να τυπώσετε τα γράμματα:

2. 2. 2: 049> H H H H H HHHHHHHHH H H H H H ΗΗΕEEEEEE E EEEEEEEEE E EEEEEEEEE L L L L L LLLLLLLL L L L L L L LLLLLLLLL OOO O O O O O O O OOO => nil

Αυτό το είδος έργων εκτυπώνεται κάθετα.Θα ήταν ωραίο αν τα γράμματα είχαν τοποθετηθεί οριζόντια για να είναι εύκολο να διαβάσετε τη λέξη HELLO.

Να θυμάστε ότι οι συστοιχίες είναι σαν κουτιά με διαμερίσματα; Λοιπόν, αποδεικνύεται ότι μπορείτε να πάρετε το περιεχόμενο οποιουδήποτε από αυτά τα περιεχόμενα ζητώντας τον αριθμό διαμερίσματος όπως αυτό:

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

Εδώ παρέχετε τον αριθμό του διαμερίσματος σε αγκύλες στο όνομα της μεταβλητής πίνακα - h, στην περίπτωση αυτή.

Ακολουθήστε αυτά τα βήματα για να λάβετε τα γράμματα για εκτύπωση οριζόντια:

Συνδυάστε τα γράμματα χρησιμοποιώντας παρεμβολή συμβολοσειράς για να αποκτήσετε πρόσβαση σε κάθε πίνακα ταυτόχρονα:

2. 2. 2: 053> βάζει "# {h [0]} # {e [0]}" HH EEEEEEEEE LL OOO = nil

Μπορείτε να δείτε πώς φαίνονται τα γράμματα. Το πρόβλημα είναι ότι αν χρησιμοποιήσετε βάζει σε ξεχωριστές γραμμές στο IRB, δεν θα μοιάζει με τις γραμμές γραμμάτων όλα συνδέονται. Χρειάζεται κάποιος τρόπος να επαναλάβετε αυτή την εντολή για καθένα από τα επτά μέρη.

Μια πιο προηγμένη τεχνική που θα χρησιμοποιήσετε πολλά σε μεταγενέστερα έργα ονομάζεται

looping.

Το Looping είναι ένας τρόπος για να επαναλάβετε τον κωδικό σας αρκετές φορές. Στο Ruby, υπάρχει μια βολική μέθοδο looping που μπορείτε να καλέσετε τους αριθμούς για να μετρήσετε μέχρι έναν άλλο αριθμό. Δοκιμάστε αυτόν τον κωδικό:

2. 2. 2: 055> 0. upto (6) δεν μετράνε 2. 2. 2: 056> βάζει h [count] + "" + e [count] + "" + l [count] + "": 057; > τέλος

Μόλις πιέσετε την επιλογή Επιστροφή ή Εισαγωγή μετά την τελική γραμμή, θα πρέπει να δείτε: H H EEEEEEEEE L L OOO H H E L L O O H E L L O O HHHHHHHHH EEEEEEEEE L L O O H H L L O O H E L L O O H EEEEEEEEE LLLLLLLLL LLLLLLLLL OOO => 0

Επιτυχία! Η πρώτη γραμμή, 0. upto (6) κάνει | count. | ξεκινάει τον βρόχο. Προετοιμάζει τον Ruby να μετρά από το μηδέν έως και έξι. Καθώς ο Ruby μετρά κάθε αριθμό, τοποθετεί τον τρέχοντα αριθμό στη μεταβλητή που ονομάζεται count. Στη συνέχεια, ο Ruby προχωρά στην επόμενη γραμμή, η οποία έχει τη μέθοδο σας. Μέσα από την παρεμβολή των συμβολοσειρών που συνδυάζει όλα τα τμήματα επιστολών, ζητά πρώτα το μηδέν και εκτυπώνει αυτή τη σειρά. Επαναλαμβάνει έπειτα έξι φορές και εκτυπώνει κάθε τμήμα σε σειρά (συνολικά επτά). Η τελική γραμμή λέει στον Ruby ότι ο βρόχος πρέπει να σταματήσει εκεί.