Partition string into chunks

Question

This seems like it should be trivial, but how do I partition a string into length n substrings? I can of course write something like

chunk[s_, n_] := StringJoin[#] & /@ Partition[Characters[s], n]

so that chunk["ABCDEF",2] -> {"AB","CD","EF"} but this appears unnecessarily cumbersome.

Answer 1

Try this:

StringCases["ABCDEFGHIJK", LetterCharacter ~~ LetterCharacter]

{"AB", "CD", "EF", "GH", "IJ"}

or for more general cases (i.e. not just for letters, but any characters, and for any partition size):

stringPartition1[s_String, n_Integer] := StringCases[s, StringExpression @@ Table[_, {n}]];

It is more elegant though to use Repeated (thanks rcollyer):

stringPartition2[s_String, n_Integer] := StringCases[s, Repeated[_, {n}]];

stringPartition2["longteststring", 4]

{"long", "test", "stri"}

Answer 2

Here is the regular-expression way:

chunk[s_, n_] := 
 StringCases[s, RegularExpression[".{1," <> ToString[n] <> "}"]]

chunk["Hello this is a test string", 2]

{"He", "ll", "o ", "th", "is", " i", "s ", "a ", "te", "st", " s", "tr", "in", "g"}

chunk["Hello this is a test string", 4]

{"Hell", "o th", "is i", "s a ", "test", " str", "ing"}

Note that the last substrings didn't fit the chunk size but were still included.

If you don't want to include them, change the regular expression from ".{1," <> ToString[n] <> "}" to ".{" <> ToString[n] <> "}".

Answer 3

Another possibility:

StringTake[#, 
   Partition[Range@StringLength@#, 2, 2, 1, {}]] &@"abcdefghi"

giving

(*  {"ab", "cd", "ef", "gh", "i"} *)

Answer 4

Not completely original, but very compact.

chunk[s_, n_] := StringJoin@@@Partition[Characters[s], n, n, 1, {}]

---

Update for V10.1

This new function is exactly for that:

StringPartition["ABCDEF",2]

{"AB", "CD", "EF"}

Answer 5

This will give better performance (3 times faster in my test, partitioning into length-two strings) than your original code:

chunk[s_, n_] := FromCharacterCode@Partition[ToCharacterCode[s], n]

The reason is that the first few steps of the computation are done with packed arrays.

It will still be slower than the regex-based approaches (István's and Jens's), on my machine by a factor of 2.

The StringTake approach is much slower than all the others in my machine.

Benchmarks

Function definitions:

(* original *)
chunk1[s_, n_] := StringJoin[#] & /@ Partition[Characters[s], n]

(* István *)
chunk2[s_, n_] := StringCases[s, Repeated[_, {n}]]

(* Jens *)
chunk3[s_, n_] := StringCases[s, RegularExpression[".{1," <> ToString[n] <> "}"]]

(* TomD *)
chunk4 = StringTake[#, Partition[Range@StringLength@#, #2, #2, 1, {}]] &;

(* mine *)
chunk5[s_, n_] := FromCharacterCode@Partition[ToCharacterCode[s], n]

text = ExampleData[{"Text", "Hamlet"}];
testString = StringJoin[ConstantArray[text, 20]];

StringLength[testString] (* 3438740 *)

Timings:

(* original *)
In[10]:= Timing[chunk1[testString, 2];]
         Timing[chunk1[testString, 100];]

Out[10]= {5.968, Null}
Out[11]= {1.703, Null}

(* István - fastest *)
In[12]:= Timing[chunk2[testString, 2];]
         Timing[chunk2[testString, 100];]

Out[12]={1.25, Null}
Out[13]={0.11, Null}

(* Jens - fastest *)
In[14]:= Timing[chunk3[testString, 2];]
         Timing[chunk3[testString, 100];]

Out[14]= {1.313, Null}
Out[15]= {0.125, Null}

(* TomD *)
In[16]:= Timing[chunk4[testString, 2];]
         Timing[chunk4[testString, 100];]

(* More than a few minutes. Didn't wait for it to finish ... *)

(* mine *)
In[18]:= Timing[chunk5[testString, 2];]
         Timing[chunk5[testString, 100];]

Out[18]= {2.25, Null}
Out[19]= {0.266, Null}

Conclusion: use regex-based methods. The built-in string patterns also use a regex library internally, I believe, but they are easier to construct programmatically because they are represented as expressions.

Answer 6

I wanted a solution using StringSplit[]

chunk[s_, n_] := StringSplit[s, RegularExpression["(.{" <> ToString@n <> "})"] -> "$1"]
                                                                     ~ DeleteCases ~ ""

Answer 7

Historical note:

WolframLanguageData["StringPartition"
 , {"VersionIntroduced", "DateIntroduced"}]

{10.1, DateObject[{2015, 3, 30}, "Day", "Gregorian", 5.]}

---

The command supports UpTo as well as offset specs, similar to Partition.

str = "ABCDEFGHIJK";

StringPartition[str, UpTo[2]]

{"AB", "CD", "EF", "GH", "IJ", "K"}

StringPartition[str, 2, 1]

{"AB", "BC", "CD", "DE", "EF", "FG", "GH", "HI", "IJ", "JK"}

StringPartition[str, UpTo[7]]

{"ABCDEFG", "HIJK"}

Answer 8

Using SequenceCases (new in 10.1)

str = "ABCDEFGHIJK";

SequenceCases[Characters[str], x : {Repeated[_, {2}]} :> StringJoin[x]]

{"AB", "CD", "EF", "GH", "IJ"}

SequenceCases[Characters[str], x : {Repeated[_, {1, 2}]} :> StringJoin[x]]

{"AB", "CD", "EF", "GH", "IJ", "K"}

SequenceCases[Characters[str], x : {Repeated[_, {1, 7}]} :> StringJoin[x]]

{"ABCDEFG", "HIJK"}

SequenceCases[
 Characters[str], 
 x : {Repeated[_, {2}]} :> StringJoin[x], 
 Overlaps -> True]

{"AB", "BC", "CD", "DE", "EF", "FG", "GH", "HI", "IJ", "JK"}

SequenceCases[
 Characters[str], 
 x : {Repeated[_, {1, 2}]} :> StringJoin[x], 
 Overlaps -> True]

{"AB", "BC", "CD", "DE", "EF", "FG", "GH", "HI", "IJ", "JK", "K"}

Answer 9

str = "ABCDEFGHIJK";

---

Using MovingMap:

MovingMap["" <> # &, Characters[str], 1][[1 ;; -1 ;; 2]]

{"AB", "CD", "EF", "GH", "IJ"}