Ruby Convenience-Methode für junge Ingenieure

Einführung

** Als junger Ingenieur schreibe ich eine sehr nützliche Methode auf, während ich Algorithmusprobleme mit AtCoder und Paiza löse. ** ** **

Unterschied zwischen Puts, p, print

Ich habe versucht, es in meinen eigenen Worten zu erklären, aber es gab viele Artikel im Internet, also habe ich beschlossen, aufzuhören.

[Einführung in Ruby] Unterschiede zwischen print, put und p https://yukimasablog.com/ruby-print-puts-p [Ruby] Unterschiede zwischen p-, Puts- und Druckmethoden https://qiita.com/rkkmshde/items/daf75aca9675f5a01d17

Wenn Sie es beim Debuggen beherrschen, werden Sie den Fehler und seine Ursache beim Schreiben von kompliziertem Code sehr effizient bemerken.

Dreiecksoperator

if 〜 else 〜 end Kann effizienter geschrieben werden.

number = 24
if number.even? 
    n = "Sogar"
else
    n = "Seltsam"
end
puts n  
# =>Sogar

Dieser Prozess ist ...

number = 24
n = number.even? ? "Sogar" : "Seltsam"
puts n  
# =>Sogar

Es wird so sein.

** Bedingung? (Verarbeitung bei wahrer Bedingung): (Verarbeitung bei falscher Bedingung) **

Es ist eine Struktur.

map

#Eingegebener Wert
# 12 30 40
input = gets.split.map(&:to_i)
#Ausgabewert
# [12, 30, 40]
#Es wird eine Anordnung wie diese.

Es kann verwendet werden, wenn Sie den numerischen Wert oder die Zeichenfolge des Eingabewerts in einzelne Elemente unterteilen und ein Array erstellen möchten.

** "&:" ** Ich werde diesmal die Erklärung der Methode weglassen. Für mehr Informationen, https://qiita.com/soma_sekimoto/items/a828b8f88b78aac2e7df Lesen Sie diesen Artikel.

irgendwelche?, alle? Und eine?

Diese Methoden sind sehr nützlich, wenn Sie die iterative Verarbeitung verwenden möchten, um festzustellen, ob die Bedingungen erfüllt sind **.

Als ich das nicht wusste, habe ich versucht, jeden zu ersetzen, also war der Code lächerlich.

array = [30, 14, 23, 15]
array.any? {|num| num % 7 == 0} #Elemente teilbar durch 7(14)Es gibt
# => true  

** any? **: Gibt true zurück, wenn eines der Elemente die Bedingungen erfüllt.

** all? **: Gibt true zurück, wenn alle Elemente die Bedingungen erfüllen.

** eins? **: Gibt true zurück, wenn nur eines von jedem Element die Bedingungen erfüllt.

reduce

(1..10).reduce(5) {|a, n| a + n}
# => 5 + 1 = 6,Diese 6 wird zum nächsten Prozess.
#Mit anderen Worten ist der zweite Prozess 6+Es wird 2.
#Verarbeitungsergebnis=> 60

Setzen Sie bei der Reduktionsmethode zwei Argumente (a und n) in der Blockverarbeitung. a ist der Anfangswert (hier 5) und n ist jedes Element (hier eine ganze Zahl von 1 bis 10).

between?

23.between?(0, 30)
# => true

'G'.between?('A', 'F')
# => false

Eine Methode, um festzustellen, ob die angegebenen Werte (hier 23 und 'G') innerhalb des Bereichs (0-30 und A-F) liegen.

index

array = ["ruby", "java", "php"]
p array.index("java")
# => 1
# "java"Die Indexnummer wird zurückgegeben.

transpose ** Eine Methode, die ein Array als Matrix betrachtet ** und Zeilen und Spalten austauscht, wenn das Array andere Arrays als Elemente enthält **

array = [[1,2,3,4], [5,6,7,8], [9,10,11,12]]
p array.transpose
# => [[1,5,9], [2,6,10], [3,7,11], [4,8,12]]

Er war sehr aktiv in algorithmischen Problemen, die die Idee von Zeilen und Spalten verwendeten.

chars

greeting = "hello"
p greeting.chars
# => ["h", "e", "l", "l", "o"]

Wie oben beschrieben, ** wird die Zeichenfolge in Zeichen unterteilt und als Array zurückgegeben **.

Sie können auch so schreiben.

num = "19800".chars.map(&:to_i)
p num
# => [1, 9, 8, 0, 0]

Es kann verwendet werden, wenn Sie ziffernweise Zahlen verarbeiten möchten. zip Diese Zip-Methode ist nützlich, wenn Sie mehrere Arrays gleichzeitig verarbeiten möchten.

number = [1, 2, 3, 4, 5]
alphabet = ["a", "b", "c", "d", "e"]
p number.zip(alphabet)
number.zip(alphabet) do |num, alpha|
    p num
    p alpha
end

# => [[1, "a"], [2, "b"], [3, "c"], [4, "d"], [5, "e"]]

# => 1
# => "a"
# => 2
# => "b"
...
# => 5
# => "e"

Wie oben beschrieben, kann es als Array zurückgegeben oder mithilfe der einzelnen Methoden für mehrere Arrays verarbeitet werden.

select, reject ** select **: {} Extrahiere nur die Elemente, deren Ausdruck im Block wahr ist. ** ablehnen **: {} Extrahiere nur die Elemente, deren Ausdruck im Block falsch ist.

p [1, 2, 3, 4, 5, 6].select { |n| n % 2 == 0 }
p [1, 2, 3, 4, 5, 6].reject { |n| n % 2 == 0 }
# => [2, 4, 6]
# => [1, 3, 5]

abschließend

Im Vergleich zu anderen Sprachen verfügt Ruby über mehr Methoden, sodass ich erkannte, dass ich intuitiven Code schreiben konnte, und ich mochte Ruby noch mehr.

Ich möchte, dass sich alle darauf beziehen, wenn sie Algorithmen mit Ruby schreiben.