Introduction

** As a fledgling engineer, I write down a method that was very useful while solving algorithm problems with AtCoder and paiza. ** **

Differences between puts, p and print

I tried to explain it in my own words, but there were a lot of articles on the web, so I decided to stop.

[Introduction to Ruby] Differences between print, puts, and p https://yukimasablog.com/ruby-print-puts-p [Ruby] Differences between p, puts, and print methods https://qiita.com/rkkmshde/items/daf75aca9675f5a01d17

If you can master it when debugging, you will notice errors and their causes quite efficiently when writing complex code.

Ternary operator

if 〜 else 〜 end Can be written more efficiently.

``````number = 24
if number.even?
n = "Even"
else
n = "Odd"
end
puts n
# =>Even

``````

This process is ...

``````number = 24
n = number.even? ? "Even" : "Odd"
puts n
# =>Even
``````

It will be like this.

** Condition? (Processing when condition is true): (Processing when condition is false) **

It is a structure.

map

``````#Input value
# 12 30 40
input = gets.split.map(&:to_i)
#Output value
# [12, 30, 40]
#It becomes an array like this.
``````

It can be used when you want to divide the numerical value or character string of the input value into individual elements and make an array.

any?, all? And one?

These methods are very useful when you want to use iterative processing to see if the conditions are met **.

When I didn't know this, I was trying to substitute each for everything, so the code was ridiculous.

``````array = [30, 14, 23, 15]
array.any? {|num| num % 7 == 0} #Elements divisible by 7(14)There is
# => true
``````

** any? **: Returns true if at least one of each element meets the conditions.

** all? **: Returns true if all elements meet the conditions.

** one? **: Returns true if only one of each element meets the conditions.

reduce

``````(1..10).reduce(5) {|a, n| a + n}
# => 5 + 1 = 6,This 6 becomes a of the next process.
#In other words, the second process is 6+It becomes 2.
#Processing result=> 60
``````

In the reduce method, set two arguments (a and n) in the block process. a is the initial value (here 5) and n is each element (here, an integer from 1 to 10).

between?

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

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

A method to determine if the specified values (here 23 and'G') are within the range (0-30 and A-F)

index

``````
array = ["ruby", "java", "php"]
p array.index("java")
# => 1
# "java"Index number is returned.
``````

transpose ** A method that considers an array as a matrix ** and swaps rows and columns when the array contains other arrays as elements **

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

He was very active in algorithmic problems that used the idea of rows and columns.

chars

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

As described above, ** the character string is divided into characters and returned as an array **.

You can also write like this.

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

It can be used when you want to process digit-by-digit numbers. zip This zip method is useful when you want to process multiple arrays at the same time.

``````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"
``````

As mentioned above, it can be returned as an array, or it can be processed by using the each method for multiple arrays.

select, reject ** select **: {} Extract only the elements whose expression is true in the block. ** reject **: {} Extract only the elements whose expression is false in the block.

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

in conclusion

Compared to other languages, ruby has more methods, so I realized that I could write intuitive code, and I became more fond of ruby.

I would like everyone to refer to it when writing algorithms using ruby.