I have an array:
["apple", "banana", "animal", "car", "angel"]
I want to push elements that start with "a" into separate arrays. I want to return:
["apple"], ["animal"], ["angel"]
I have only been able to make it work if I push them into an empty array that I pre-created.
Generally in order to pick elements from array that match some specific conditione use select method.
select returns an array of all elements that matched critera or an empty list in case neither element has matched
example:
new_array = array.select do |element|
return_true_or_false_depending_on_element(element)
end
now when we would like to put every element in its own array we could you another array method that is available on array - map which takes every element of an array and transforms it in another element. In our case we will want to take every matching string and wrap it in array
map usage:
new_array = array.map do |element|
element_transformation(element) # in order to wrap element just return new array with element like this: [element]
end
coming back to your question. in order to verify whether a string starts with a letter you could use start_with? method which is available for every string
glueing it all together:
strings = ["apple", "banana", "animal", "car", "angel"]
result = strings.select do |string|
string.start_with?("a")
end.map do |string_that_start_with_a|
[string_that_start_with_a]
end
puts result
reject is the exact opposite of select: reject Returns a new array containing the items in self for which the block is not true (apidock.com/ruby/Array/reject)
select is clearly the way to go, but I would prefer to see your answer shortened and tighteneed. Were it me, I would just define strings as you have and write strings.select { |string| string.start_with?(a) } #=> ["apple", "animal", "angel"], then explain that Array#select returns an array consisting of all elements string of strings for which string.start_with?("a") evaluates true.
string.start_with?("a") vs string[0] == "a"? Just curious.start_with? seems to be more ruby idiomatic approach. Things get more complicated in case you would have an empty string inside an array - string[0] would return nil, so essentially you would be comparing nil against "a" which will work as we think it should work, but it's a bit tricky. it's even more fun when you test if empty string starts with an empty string (test yourself ""[0] == "" and "".start_with?(""))Here's a golfed down version:
array.grep(/\Aa/).map(&method(:Array))
I might consider my audience before putting something this clever into production, since it can be a little confusing.
Array#grep returns all elements that match the passed regular expression, in this case /\Aa/ matches strings that begin with a. \A is a regular expression token that matches the beginning of the string. You could change it to /\Aa/i if you want it to be case insensitive.
The &method(:Array) bit grabs a reference to the kernel method Array() and runs it on each element of the array, wrapping each element in the array in its own array.
.map{|s|[s]} saves 9 characters. grep is good.
array.grep(/\Aa/).map { |word| [word] }.The simplest I can come up with is:
arr = %w{ apple banana animal car angel }
arr.map {|i| i.start_with?('a') ? [i] : nil }.compact
=> [["apple"], ["animal"], ["angel"]]
start_with? does not return the value but a boolean result. Otherwise you would not need the operator.Here is some code I got to do this in console:
> arr = ["apple", "banana", "animal", "car", "angel"]
=> ["apple", "banana", "animal", "car", "angel"]
> a_words = []
=> []
arr.each do |word|
a_words << word if word.chars.first == 'a'
end
=> ["apple", "banana", "animal", "car", "angel"]
> a_words
=> ["apple", "animal", "angel"]
If you wanted to do something more complex than first letter you might want to use a regex like:
if word.matches(/\Aa/) # \A is beginning of string
word[0] instead of word.chars.first.array_of_arrays = []
your_array.each do |ele|
if ele.starts_with?("a")
array_of_arrays << ele.to_a
end
end
arr, return an array comprised of the those elements ofarrthat begin with"a", in the same order. The way it is now worded it sounds like you wish to create a new empty array, sayb, and then iterate overarr, executingb.push(string)(orb << string) when the elementstringofarrbegins with an"a". Do you see how that unnecessarily restricts the method of solution? @djaszczurowski's answer, for example, does not seem to meet your requirements but, imo, is the best answer.["apple"],["animal"],["angel"]is not an object. I assume you mean you wish to return an array. Do you want[["apple"], ["animal"], ["angel"]]or["apple", "animal", "angel"]? Some answers assume the former is wanted.