Regular Expression group repeated letters

Question

I am trying to group all the repeated letters in a string.

Eg:

"aaaaaaabbbbbbbbc" => [['aaaaaaa'],['bbbbbbbb'],['c']]

Using logic and Ruby, the only way I could find to reach my intention was:

.scan(/(?:a+|A+)|(?:b+|B+)|(?:c+|C+)| ..... (?:y+|Y+)|(?:z+|Z+))

where ... are the other alphabet letters.

There is a way to Dry that RegEx? I used backtrace (\1) too, but it doesn't match the single words and it doesn't return me the exact letters match => (\w+)\1 => [['aa'],['bb']]

Uhm, am I wrong to use the regular expressions for this case and I should use Ruby methods with iterations?

I will glad to hear your opinion :) Thanks!

Do you really want `[['aaaaaaa'], ['bbbbbbbb'], ['c']]` and not just `['aaaaaaa', 'bbbbbbbb', 'c']`? — Stefan, Oct 28 '17 at 11:57
The answers reflect some confusion about your question. Do you want the return value for `"abab"` to be `["a", "b", "a", "b"]` or `["aa", "bb"]`? — Cary Swoveland, Oct 28 '17 at 17:32
In case you didn't know, you can upvote the answer you've selected. — Cary Swoveland, Oct 29 '17 at 01:14

Avinash Raj · Accepted Answer · 2017-10-29T11:00:43.057

7

Just use another capturing group to catch the repeated characters.

s.scan(/((\w)\2*)/).map(&:first)
# => ["aaaaaaa", "bbbbbbbb", "c"]

edited Oct 29 '17 at 11:00

answered Oct 28 '17 at 14:59

Avinash Raj

172,303
28
230
274

1

Interesting! You could instead write `map(&:first)`. The way [String#scan](http://ruby-doc.org/core-2.4.0/String.html#method-i-scan) deals with groups is like that double-edged sword you are holding: it's either convenient or--as here--an irritating impediment. – Cary Swoveland Oct 28 '17 at 21:18
@Cary Thanks as always :-) – Avinash Raj Oct 29 '17 at 11:01
I like this solution, but I also I want to understand it. Could someone put into words how the regexp is set up, especially '\2*' ? Thanks! – krystonen Dec 11 '18 at 11:19
1

@Krisztina in regex, we use `\` to refer the corresponding captured chars, say `\1` refers to the chars which are capturing by the first capturing group `()` whereas the `\2` refers to the 2nd capturing group. Likewise it goes on. So here `(\w)` should capture all the word chars and `(\w)\1*` matches all word chars as well as the following 0 or more repeated chars. say it matches `b`, `nn`, `b` in `bnnb` input string. Since the `scan` func returns only the captured chars, I again wrap the whole regex inside another group. – Avinash Raj Dec 11 '18 at 15:07
1

But if we use the `\1`, it still refers to the first group but we want the second one that's why I used `\2` – Avinash Raj Dec 11 '18 at 15:08

score 2 · Answer 2 · answered Oct 28 '17 at 16:44

2

One more solution without regexp :)

"aaaaaaabbbbbbbbc".chars.group_by(&:itself).values.map { |e| [e.join] }
 #=> [["aaaaaaa"], ["bbbbbbbb"], ["c"]]

answered Oct 28 '17 at 16:44

Oleksandr Holubenko

4,310
2
14
28

Sebastián Palma · Answer 3 · 2017-10-28T11:43:28.667

1

Without using a regex you could take a look to Enumerable#slice_when:

string = "aaaaaaabbbbbbbbc"
p string.chars.sort.slice_when { |a, b| a != b }.map { |element| element.join.split }
# [["aaaaaaaa"], ["bbbbbbbb"], ["c"]]

edited Oct 28 '17 at 11:43

answered Oct 28 '17 at 11:21

Sebastián Palma

32,692
6
40
59

1

Isn't `map(&:join)` sufficient? I suggest using `each_char` rather than `chars` whenever it is followed by an enumerable (to avoid creating an unnecessary intermediate array). – Cary Swoveland Oct 28 '17 at 20:53
It's because of the output he added @Cary, only `map(&:join)` gives `["aaaaaaa", "bbbbbbbb", "c"]`. – Sebastián Palma Oct 28 '17 at 21:04
1

Oh, yes, that! In that case `map { |element| [element.join] }` may be easier to understand. – Cary Swoveland Oct 28 '17 at 21:08
I thought about it also with Alex's answer :), thanks for the `each_char` suggestion. – Sebastián Palma Oct 29 '17 at 11:27

Cary Swoveland · Answer 4 · 2017-10-28T21:12:13.907

Here are a few other ways ways to do that. All return ["aaaaaaa", "bbbbbbbb", "c"]. If [["aaaaaaa"], ["bbbbbbbb"], ["c"]] is truly wanted (I can't imagine why), that's a simple extra step using map.

s.each_char.chunk(&:itself).map(&:join)

s.each_char.chunk_while { |a,b| b == a }.map(&:join)

s[1..-1].each_char.with_object([s[0]]) {|c,a| c == a.last[0] ? (a.last<<c) : a<< c}

s.gsub(/(.)\1*/).with_object([]) { |t,a| a << t }

In the last of these, String#gsub does not have a block, so it returns an enumerator (and does not perform any character replacement.) This use of gsub can be used to advantage in many situations.

Regular Expression group repeated letters

4 Answers4