langref.org - clojure, cpp, csharp, erlang ... - Regex | Searching | Loop through a string matching a regex and performing an action for each match

View Problem

Regex

Searching

Loop through a string matching a regex and performing an action for each match

Create a list [fish1,cow3,boat4] when matching "(fish):1 sausage (cow):3 tree (boat):4" with regex /$(\w+)$:(\d+)/

clojure

(let [matcher (re-matcher #"$(\w+)$:(\d+)" "(fish):1 sausage (cow):3 tree (boat):4")]
(loop [match (re-find matcher)
lst []]
(if match
(recur (re-find matcher) (conj lst (str (second match) (nth match 2))))
lst)))

cpp C++/CLI .NET 2.0

Match^ match = Regex::Match("(fish):1 sausage (cow):3 tree (boat):4", "\$(\\w+)\$:(\\d+)");

while (match->Success)
{
list->Add(match->Groups[1]->Captures[0]->ToString() + match->Groups[2]->Captures[0]->ToString());
match = match->NextMatch();
}

csharp .net 2.0 but compiled with c# 3.0

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public static class extensions {
public static IList<string> Map(this string me, string pattern, Func<Match, string> action){
IList<string> matches = new List<string>();
foreach (Match match in Regex.Matches(me,pattern)){
matches.Add(action(match));
}
return matches;
}
}

class Test
{
static void Main()
{
IList<string> list = "(fish):1 sausage (cow):3 tree (boat):4".Map(@"$(\w+)$:(\d+)", (m) => {return m.Groups[1].Value + m.Groups[2].Value;});
}
}

erlang R13

solve(S) ->
R = "\$(\\w+?)\$:(\\d+)",
{match, M} = re:run(S,R, [global, {capture, all_but_first, list}]),
[ A++N || [A, N] <- M].

fantom

m := Regex<|$(\w+)$:(\d+)|>.matcher(s)
list := Str[,]
while (m.find) { list.add("${m.group(1)}${m.group(2)}") }

fsharp

let list = new ResizeArray<string>()
let mutable regmatch = (Regex.Match("(fish):1 sausage (cow):3 tree (boat):4", "\$(\\w+)\$:(\\d+)"))

while regmatch.Success do
list.Add(regmatch.Groups.[1].Captures.[0].ToString() ^ regmatch.Groups.[2].Captures.[0].ToString())
regmatch <- regmatch.NextMatch()
done

for word in list do printfn "%s" word done

fsharp

// A solution without mutation:
let results =
Regex.Matches("(fish):1 sausage (cow):3 tree (boat):4", "\$(\\w+)\$:(\\d+)")
|> Seq.cast
|> Seq.map (fun (regmatch: Match) ->
regmatch.Groups.[1].Captures.[0].ToString() + regmatch.Groups.[2].Captures.[0].ToString()
)
|> List.ofSeq

groovy

list = (text =~ /$(\w+)$:(\d+)/).collect{ it[1] + it[2] }

groovy

list = []
text.eachMatch(/$(\w+)$:(\d+)/){
list << it[1] + it[2]
}

groovy

list = []
text.eachMatch(/$(\w+)$:(\d+)/){ m, name, number ->
list << "$name$number"
}

groovy

list = (text =~ /$(\w+)$:(\d+)/).collect{ all, name, num -> "$name$num" }

groovy 1.6.1+

list = text.findAll(regex){ _, name, num -> "$name$num" }

groovy 1.6.1+

list = text.findAll(regex){ it[1] + it[2] }

java

List list = new ArrayList();
Pattern pattern = Pattern.compile("\$(\\w+)\$:(\\d+)");
Matcher matcher = pattern.matcher(text);
while(matcher.find()) {
list.add(matcher.group(1)+matcher.group(2));
}

ocaml

let result =
let str = "(fish):1 sausage (cow):3 tree (boat):4" in
let ms = Pcre.exec_all ~pat:"\$(\\w+)\$:(\\d+)" str in
Array.to_list (
Array.map (fun m ->
let s = Pcre.get_substrings m in
Printf.sprintf "%s%s" s.(1) s.(2);
) ms
)

perl

while ($text =~ /$(\w+)$:(\d+)/g) {
push @list, "$1$2"
}

php

preg_match_all("/$(\w+)$:(\d+)/", "(fish):1 sausage (cow):3 tree (boat):4", $matches);
for ($i=0, $c=count($matches[0]); $i < $c; $i++) {
$list[] = $matches[1][$i].$matches[2][$i];
}

python

map(''.join, re.findall(r"$(\w+)$:(\d+)", "(fish):1 sausage (cow):3 tree (boat):4"))
--------------------------------------------------------------------------
(''.join(m.groups()) for m in re.finditer(r"$(\w+)$:(\d+)", "(fish):1 sausage (cow):3 tree (boat):4"))

ruby

list = text.scan(/$(\w+)$:(\d+)/).collect{|x| x.join}

ruby

list=[]
text.scan(/$(\w+)$:(\d+)/) {
list << $1+$2
}

scala

val m = Pattern.compile("\$(\\w+)\$:(\\d+)").matcher("(fish):1 sausage (cow):3 tree (boat):4")
var list : List[String] = Nil

while (m.find) list = (m.group(1) + m.group(2)) :: list ; list = list.reverse

Submit a new solution for clojure, cpp, csharp, erlang ...
There is 1 other solution in haskell