Méthode de commodité Ruby pour les jeunes ingénieurs

introduction

** En tant qu'ingénieur débutant, j'écris une méthode très utile pour résoudre des problèmes d'algorithme avec AtCoder et paiza. ** **

Différence entre les put, p, imprimer

J'ai essayé de l'expliquer avec mes propres mots, mais il y avait beaucoup d'articles sur le web, alors j'ai décidé d'arrêter.

[Introduction à Ruby] Différences entre print, put et p https://yukimasablog.com/ruby-print-puts-p [Ruby] Différences entre les méthodes p, met et print https://qiita.com/rkkmshde/items/daf75aca9675f5a01d17

Si vous pouvez le maîtriser lors du débogage, vous remarquerez l'erreur et sa cause assez efficacement lors de l'écriture de code compliqué.

Opérateur triangulaire

if 〜 else 〜 end Peut être écrit plus efficacement.

number = 24
if number.even? 
    n = "Même"
else
    n = "Impair"
end
puts n  
# =>Même

Ce processus est ...

number = 24
n = number.even? ? "Même" : "Impair"
puts n  
# =>Même

Ce sera comme ça.

** Condition? (Traitement lorsque la condition est vraie): (Traitement lorsque la condition est fausse) **

C'est une structure.

map

#Valeur d'entrée
# 12 30 40
input = gets.split.map(&:to_i)
#Valeur de sortie
# [12, 30, 40]
#Cela devient un arrangement comme celui-ci.

Il peut être utilisé lorsque vous souhaitez diviser la valeur numérique ou la chaîne de caractères de la valeur d'entrée en éléments individuels et créer un tableau.

** "&:" ** Je vais omettre l'explication de la méthode cette fois. Pour plus d'informations, https://qiita.com/soma_sekimoto/items/a828b8f88b78aac2e7df Reportez-vous à cet article.

un?, tous? et un?

Ces méthodes sont très utiles lorsque vous souhaitez utiliser un traitement itératif pour voir si les conditions sont remplies **.

Quand je ne savais pas cela, j'essayais de remplacer chacun, donc le code était ridicule.

array = [30, 14, 23, 15]
array.any? {|num| num % 7 == 0} #Éléments divisibles par 7(14)Il y a
# => true  

** any? **: renvoie vrai si l'un des éléments remplit les conditions.

** all? **: renvoie vrai si tous les éléments remplissent les conditions.

** one? **: renvoie vrai si un seul de chaque élément remplit les conditions.

reduce

(1..10).reduce(5) {|a, n| a + n}
# => 5 + 1 = 6,Ce 6 devient un du processus suivant.
#En d'autres termes, le deuxième processus est 6+Cela devient 2.
#Résultat du traitement=> 60

Dans la méthode de réduction, définissez deux arguments (a et n) dans le traitement de bloc. a est la valeur initiale (ici 5) et n est chaque élément (ici, un entier de 1 à 10).

between?

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

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

Une méthode pour déterminer si les valeurs spécifiées (ici 23 et 'G') sont dans la plage (0-30 et A-F)

index

array = ["ruby", "java", "php"]
p array.index("java")
# => 1
# "java"Le numéro d'index est renvoyé.

transpose ** Une méthode qui considère un tableau comme une matrice ** et permute les lignes et les colonnes lorsque le tableau contient d'autres tableaux comme éléments **

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]]

Il était très actif dans les problèmes algorithmiques qui utilisaient l'idée de lignes et de colonnes.

chars

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

Comme décrit ci-dessus, ** la chaîne de caractères est divisée en caractères et renvoyée sous forme de tableau **.

Vous pouvez également écrire comme ça.

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

Il peut être utilisé lorsque vous souhaitez traiter des nombres chiffre par chiffre. zip Cette méthode zip est utile lorsque vous souhaitez traiter plusieurs tableaux en même temps.

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"

Comme décrit ci-dessus, il peut être renvoyé sous forme de tableau, ou il peut être traité à l'aide de la méthode each pour plusieurs tableaux.

select, reject ** select **: {} Extrayez uniquement les éléments dont l'expression est vraie dans le bloc. ** rejet **: {} Extrayez uniquement les éléments dont l'expression est fausse dans le bloc.

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]

en conclusion

Comparé à d'autres langages, ruby a plus de méthodes, alors j'ai réalisé que je pouvais écrire du code intuitif, et je suis devenu encore plus friand de ruby.

J'aimerais que tout le monde s'y réfère lors de l'écriture d'algorithmes utilisant ruby.