Elegant and fast way to join all string sequences

Question

I want to do what title says:

{"a","b",1,2,3,4,"a",2,2,2,"edg","?"} => {"ab",1,2,3,4,"a",2,2,2,"edg?"}

in the most elegant way. For example one replacement rule for ReplaceAll.

I have manage to do this:

test = {"a", "a", 1, 2, "A", "b", 123, "a", "end"}
SplitBy[test, Head] /. {x__String} :> StringJoin[{x}] // Flatten

{"aa", 1, 2, "Ab", 123, "aend"}

But I find this way inelegant. Could You help me with creating good pattern?

Edit

Bonus request: It should be comparable in duration.

Also there is not need to do this via pattern-matching.

Conclusion:

There are many great answers. Each one is educational and worth an upvote. I should now accept one, the problem is I have not stated this question's goal so clearly, my fault.

• rm -rf's is the fastes and the shortest however,
• I decided to accept Jacob's answer as the fastest one and because it seems it has not focused attention as it deserves.
• Yves Klett answer fulfill my need of a single pattern solution.

As Mr. Wizard pointed out one could think I should accept rm- rf's answer. One could also think Yves Klett should receive it as his answer fits my primordial need. I will abuse a vague form of this question to give them a bounty insted.

Answer 1

R.M's answer below is faster and way shorter than this one

The main idea of this answer is to avoid testing if elements of the list are strings, but rather to infer which elements are the strings, to get a speed increase. Here is the function

joinStringsInList[list_] :=
 Module[
  {splitList = SplitBy[list, StringQ], strs, others, len, bool}, 
  bool = StringQ[First[test]];
  len = Length[splitList];

  {strs, others} =
   If[
    bool,
    {StringJoin /@ splitList[[1 ;; len ;; 2]],
     splitList[[2 ;; len ;; 2]]},
    {StringJoin /@ splitList[[2 ;; len ;; 2]],
     splitList[[1 ;; len ;; 2]]}
    ];
  Flatten[Riffle[strs, others], 1]
  ]

Example:

test = {"a", "a", {1, 1}, bool, testSplit, 2, "A", "b", 123, "a", 
  "end"}

joinStringsInList[test]

{"aa", {1, 1}, bool, testSplit, 2, "Ab", 123, "aend"}

Answer 2

Ok, since you dismissed SplitBy, which IMO is quite clean, and you wanted other's ideas, here's an unconventional solution that relies on a side-effect of how StringJoin works :)

list = {"a", "b", 1, 2, 3, 4, "a", 2, 2, 2, "edg", "?"};
List @@ Quiet@StringJoin@list
(* {"ab", 1, 2, 3, 4, "a", 2, 2, 2, "edg?"} *)

I wouldn't recommend this for production code. Stick with your SplitBy solution (or a faster alternative answer).

A cleaner version using StringExpression (thanks to Rojo):

List @@ StringExpression @@ list

which probably works very similar to Simon's answer because of the Flat and OneIdentity attribute of StringExpression.

Answer 3

I think this satisfies all the requirements, except for elegance and speed:

SetAttributes[f, {Flat, OneIdentity}]
f[a_String, b_String] := a <> b

test = {"a", "a", 1, 2, "A", "b", 123, "a", "end"};
List @@ f @@ test

(* {"aa", 1, 2, "Ab", 123, "aend"} *)

Answer 4

If we are going for least efficient here, I think I may have a winner (using Fold):

ffs[any___, a_String, b_String] := Sequence[any, StringJoin[a, b]];
ffs[any___] := Sequence[any];

with

list = {"a", "b", 1, 2, 3, 4, "a", 2, 2, 2, "edg", "?"};

Rest@{Fold[ffs, 1, list]}
(* {"ab", 1, 2, 3, 4, "a", 2, 2, 2, "edg?"} *)

The "1" being auxiliary hence dropped.

--EDIT--

Actually amending a little bit makes this quite efficient:

 ffs2[any___] := {any}
 ffs2 /: ffs2[{any___, a_String}, b_String] := ffs2[any, StringJoin[a, b]];

and

Rest@Flatten@Fold[ffs2, 1, list]
(* {"ab", 1, 2, 3, 4, "a", 2, 2, 2, "edg?"}*)

and it can deal with longer lists a little better than the one originally proposed by Kuba:

longlist = NestList[PadLeft, list, 100000] // Flatten;
AbsoluteTiming[mine = Rest@Flatten@Fold[ffs2, 1, longlist];]
AbsoluteTiming[original = SplitBy[longlist, Head] /. {x__String} :> StringJoin[{x}] //Flatten;]
mine == original

(* {1.370464, Null} *)
(* {1.556161, Null} *)
(* True *)

Answer 5

How about this (bad performance duly noted):

test = {"a", "a", 1, 2, "A", "b", 123, "a", "end"};

test //. {a___, b_String, c_String, d___} :> {a, b <> c, d}

or

test //. {a___, b : Longest[_String ..], c___} :> {a, StringJoin@b, c}

{"aa", 1, 2, "Ab", 123, "aend"}

Answer 6

A semi-pattern approach...

list = {"a","b",1,2,3,4,"a",2,2,2,"edg","?"};
Apply[Join, SplitBy[list, Head] /. {x__String} :> {StringJoin[x]}]

{ab,1,2,3,4,a,2,2,2,edg?}

The StringJoin[x] is in a list so the Apply[Join... will only strip the top-level lists SplitBy introduces. This allows elements of list to be Lists as well.

list = {"a", "b", 1, 2, {3}, 4, "a", 2, 2, 2, "edg", "?"};
Apply[Join,SplitBy[list, Head]/.{x__String}:>{StringJoin[x]}]

{ab,1,2,{3},4,a,2,2,2,edg?}

{3} is still a List.

Answer 7

Just for fun, a different way:

test={"a","b",1,2,3,4,"a",2,2,2,"edg","x"};
d=StringSplit[FixedPoint[StringReplace[#,RegularExpression["(\\D+),(\\D+)"]:>"$1"<>"$2" ]&,ToString@Row[test,","]],","];
d/.x_String /; StringMatchQ[x, NumberString] :> ToExpression[x]

(* {"ab", 1, 2, 3, 4, "a", 2, 2, 2, "edgx"} *)