Tokenize a string

From Rosetta Code
Jump to: navigation, search
Task
Tokenize a string
You are encouraged to solve this task according to the task description, using any language you may know.

Separate the string "Hello,How,Are,You,Today" by commas into an array (or list) so that each element of it stores a different word. Display the words to the 'user', in the simplest manner possible, separated by a period. To simplify, you may display a trailing period.

Related tasks:


Contents

[edit] ACL2

(defun split-at (xs delim)
(if (or (endp xs) (eql (first xs) delim))
(mv nil (rest xs))
(mv-let (before after)
(split-at (rest xs) delim)
(mv (cons (first xs) before) after))))
 
(defun split (xs delim)
(if (endp xs)
nil
(mv-let (before after)
(split-at xs delim)
(cons before (split after delim)))))
 
(defun css->strs (css)
(if (endp css)
nil
(cons (coerce (first css) 'string)
(css->strs (rest css)))))
 
(defun split-str (str delim)
(css->strs (split (coerce str 'list) delim)))
 
(defun print-with (strs delim)
(if (endp strs)
(cw "~%")
(progn$ (cw (first strs))
(cw (coerce (list delim) 'string))
(print-with (rest strs) delim))))

Output:

> (print-with (split-str "Hello,How,Are,You,Today" #\,) #\.)
Hello.How.Are.You.Today.

[edit] ActionScript

var hello:String = "Hello,How,Are,You,Today";
var tokens:Array = hello.split(",");
trace(tokens.join("."));
 
// Or as a one-liner
trace("Hello,How,Are,You,Today".split(",").join("."));

[edit] Ada

with Ada.Strings.Fixed; use Ada.Strings.Fixed;
with Ada.Text_Io; use Ada.Text_Io;
 
procedure Parse_Commas is
Source_String : String := "Hello,How,Are,You,Today";
Index_List : array(Source_String'Range) of Natural;
Next_Index : Natural := Index_List'First;
begin
Index_List(Next_Index) := Source_String'First;
while Index_List(Next_Index) < Source_String'Last loop
Next_Index := Next_Index + 1;
Index_List(Next_Index) := 1 + Index(Source_String(Index_List(Next_Index - 1)..Source_String'Last), ",");
if Index_List(Next_Index) = 1 then
Index_List(Next_Index) := Source_String'Last + 2;
end if;
Put(Source_String(Index_List(Next_Index - 1)..Index_List(Next_Index)-2) & ".");
end loop;
end Parse_Commas;

[edit] ALGOL 68

main:(
 
OP +:= = (REF FLEX[]STRING in out, STRING item)VOID:(
[LWB in out: UPB in out+1]STRING new;
new[LWB in out: UPB in out]:=in out;
new[UPB new]:=item;
in out := new
);
 
PROC string split = (REF STRING beetles, STRING substr)[]STRING:(
""" Split beetles where substr is found """;
FLEX[1:0]STRING out;
INT start := 1, pos;
WHILE string in string(substr, pos, beetles[start:]) DO
out +:= STRING(beetles[start:start+pos-2]);
start +:= pos + UPB substr - 1
OD;
IF start > LWB beetles THEN
out +:= STRING(beetles[start:])
FI;
out
);
 
PROC char split = (REF STRING beetles, STRING chars)[]STRING: (
""" Split beetles where character is found in chars """;
FLEX[1:0]STRING out;
FILE beetlef;
associate(beetlef, beetles); # associate a FILE handle with a STRING #
make term(beetlef, chars); # make term: assign CSV string terminator #
 
PROC raise logical file end = (REF FILE f)BOOL: except logical file end;
on logical file end(beetlef, raise logical file end);
 
STRING solo;
DO
getf(beetlef, ($g$, solo));
out+:=solo;
getf(beetlef, ($x$)) # skip CHAR separator #
OD;
except logical file end:
SKIP;
out
);
 
STRING beetles := "John Lennon, Paul McCartney, George Harrison, Ringo Starr";
 
printf(($g"."$, string split(beetles, ", "),$l$));
printf(($g"."$, char split(beetles, ", "),$l$))
)

Output:

John Lennon.Paul McCartney.George Harrison.Ringo Starr.
John.Lennon..Paul.McCartney..George.Harrison..Ringo.Starr.

[edit] AutoHotkey

string := "Hello,How,Are,You,Today"
stringsplit, string, string, `,
loop, % string0
{
msgbox % string%A_Index%
}

[edit] AWK

BEGIN {
s = "Hello,How,Are,You,Today"
split(s, arr, ",")
for(i=1; i < length(arr); i++) {
printf arr[i] "."
}
print
}

A more idiomatic way for AWK is

BEGIN { FS = "," }
{
for(i=1; i <= NF; i++) printf $i ".";
print ""
}

which "tokenize" each line of input and this is achieved by using "," as field separator

[edit] BASIC

[edit] Applesoft BASIC

100 T$ = "HELLO,HOW,ARE,YOU,TODAY"
110 GOSUB 200"TOKENIZE
120 FOR I = 1 TO N
130 PRINT A$(I) "." ;
140 NEXT
150 PRINT
160 END
 
200 IF N = 0 THEN DIM A$(256)
210 N = 1
220 A$(N) = "
230 FOR TI = 1 TO LEN(T$)
240 C$ = MID$(T$, TI, 1)
250 T = C$ = ","
260 IF T THEN C$ = "
270 N = N + T
280 IF T THEN A$(N) = C$
290 A$(N) = A$(N) + C$
300 NEXT TI
310 RETURN

[edit] BBC BASIC

      INSTALL @lib$+"STRINGLIB"
 
text$ = "Hello,How,Are,You,Today"
n% = FN_split(text$, ",", array$())
FOR i% = 0 TO n%-1
PRINT array$(i%) "." ;
NEXT
PRINT

[edit] Liberty BASIC

'Note that Liberty Basic's array usage can reach element #10 before having to DIM the array
For i = 0 To 4
array$(i) = Word$("Hello,How,Are,You,Today", (i + 1), ",")
array$ = array$ + array$(i) + "."
Next i
 
Print Left$(array$, (Len(array$) - 1))

[edit] PowerBASIC

PowerBASIC has a few keywords that make parsing strings trivial: PARSE, PARSE$, and PARSECOUNT. (PARSE$, not shown here, is for extracting tokens one at a time, while PARSE extracts all tokens at once into an array. PARSECOUNT returns the number of tokens found.)

FUNCTION PBMAIN () AS LONG
DIM parseMe AS STRING
parseMe = "Hello,How,Are,You,Today"
 
REDIM parsed(PARSECOUNT(parseMe) - 1) AS STRING
PARSE parseMe, parsed() 'comma is default delimiter
 
DIM L0 AS LONG, outP AS STRING
outP = parsed(0)
FOR L0 = 1 TO UBOUND(parsed) 'could reuse parsecount instead of ubound
outP = outP & "." & parsed(L0)
NEXT
 
MSGBOX outP
END FUNCTION

[edit] PureBasic

As described

NewList MyStrings.s()
 
For i=1 To 5
AddElement(MyStrings())
MyStrings()=StringField("Hello,How,Are,You,Today",i,",")
Next i
 
ForEach MyStrings()
Print(MyStrings()+".")
Next

Still, easier would be

Print(ReplaceString("Hello,How,Are,You,Today",",","."))

[edit] QBasic

DIM parseMe AS STRING
parseMe = "Hello,How,Are,You,Today"
 
DIM tmpLng1 AS INTEGER, tmpLng2 AS INTEGER, parsedCount AS INTEGER
tmpLng2 = 1
parsedCount = -1
 
'count number of tokens
DO
tmpLng1 = INSTR(tmpLng2, parseMe, ",")
IF tmpLng1 THEN
parsedCount = parsedCount + 1
tmpLng2 = tmpLng1 + 1
ELSE
IF tmpLng2 < (LEN(parseMe) + 1) THEN parsedCount = parsedCount + 1
EXIT DO
END IF
LOOP
 
IF parsedCount > -1 THEN
REDIM parsed(parsedCount) AS STRING
tmpLng2 = 1
parsedCount = -1
 
'parse
DO
tmpLng1 = INSTR(tmpLng2, parseMe, ",")
IF tmpLng1 THEN
parsedCount = parsedCount + 1
parsed(parsedCount) = MID$(parseMe, tmpLng2, tmpLng1 - tmpLng2)
tmpLng2 = tmpLng1 + 1
ELSE
IF tmpLng2 < (LEN(parseMe) + 1) THEN
parsedCount = parsedCount + 1
parsed(parsedCount) = MID$(parseMe, tmpLng2)
END IF
EXIT DO
END IF
LOOP
 
PRINT parsed(0);
FOR L0 = 1 TO parsedCount
PRINT "."; parsed(L0);
NEXT
END IF

[edit] Run BASIC

text$ = "Hello,How,Are,You,Today"
FOR i = 1 to 5
textArray$(i) = word$(text$,i,",")
print textArray$(i);" ";
NEXT

[edit] VBScript

[edit] One liner

WScript.Echo Join(Split("Hello,How,Are,You,Today", ","), ".")

In fact, the Visual Basic solution (below) could have done the same, as Join() is available.

[edit] Visual Basic

Translation of: PowerBASIC

Unlike PowerBASIC, there is no need to know beforehand how many tokens are in the string -- Split automagically builds the array for you.

Sub Main()
Dim parseMe As String, parsed As Variant
parseMe = "Hello,How,Are,You,Today"
 
parsed = Split(parseMe, ",")
 
Dim L0 As Long, outP As String
outP = parsed(0)
For L0 = 1 To UBound(parsed)
outP = outP & "." & parsed(L0)
Next
 
MsgBox outP
End Sub

[edit] Batch File

@echo off
setlocal enabledelayedexpansion
call :tokenize %1 res
echo %res%
goto :eof
 
:tokenize
set str=%~1
:loop
for %%i in (%str%) do set %2=!%2!.%%i
set %2=!%2:~1!
goto :eof

Demo

>tokenize.cmd "Hello,How,Are,You,Today"
Hello.How.Are.You.Today

[edit] Bracmat

Solution that employs string pattern matching to spot the commas

( "Hello,How,Are,You,Today":?String
& :?ReverseList
& whl
' ( @(!String:?element "," ?String)
& !element !ReverseList:?ReverseList
)
& !String:?List
& whl
' ( !ReverseList:%?element ?ReverseList
& (!element.!List):?List
)
& out$!List
)

Solution that starts by evaluating the input and employs the circumstance that the comma is a list constructing binary operator and that the string does not contain any other characters that are interpreted as operators on evaluation.

(  get$("Hello,How,Are,You,Today",MEM):?CommaseparatedList
& :?ReverseList
& whl
' ( !CommaseparatedList:(?element,?CommaseparatedList)
& !element !ReverseList:?ReverseList
)
& !CommaseparatedList:?List
& whl
' ( !ReverseList:%?element ?ReverseList
& (!element.!List):?List
)
& out$!List
)

[edit] C

Works with: ANSI C
Library: POSIX

This example uses the strtok() function to separate the tokens. This function is destructive (replacing token separators with '\0'), so we have to make a copy of the string (using strdup()) before tokenizing. strdup() is not part of ANSI C, but is available on most platforms. It can easily be implemented with a combination of strlen(), malloc(), and strcpy().

#include<string.h>
#include<stdio.h>
#include<stdlib.h>
 
int main(void)
{
char *a[5];
const char *s="Hello,How,Are,You,Today";
int n=0, nn;
 
char *ds=strdup(s);
 
a[n]=strtok(ds, ",");
while(a[n] && n<4) a[++n]=strtok(NULL, ",");
 
for(nn=0; nn<=n; ++nn) printf("%s.", a[nn]);
putchar('\n');
 
free(ds);
 
return 0;
}

Another way to accomplish the task without the built-in string functions is to temporarily modify the separator character. This method does not need any additional memory, but requires the input string to be writeable.

#include<stdio.h>
 
typedef (void *callbackfunc)(const char *);
 
void doprint(const char *s) {
printf("%s.", s);
}
 
void tokenize(char *s, char delim, callbackfunc *cb) {
char *olds = s;
char olddelim = delim;
while(olddelim && *s) {
while(*s && (delim != *s)) s++;
*s ^= olddelim = *s; // olddelim = *s; *s = 0;
cb(olds);
*s++ ^= olddelim; // *s = olddelim; s++;
olds = s;
}
}
 
int main(void)
{
char array[] = "Hello,How,Are,You,Today";
tokenize(array, ',', doprint);
return 0;
}

[edit] C#

string str = "Hello,How,Are,You,Today"; 
// or Regex.Split ( "Hello,How,Are,You,Today", "," );
// (Regex is in System.Text.RegularExpressions namespace)
string[] strings = str.Split(',');
foreach (string s in strings)
{
Console.WriteLine (s + ".");
}

[edit] C++

Works with: C++98

std::getline() is typically used to tokenize strings on a single-character delimiter

#include <string>
#include <sstream>
#include <vector>
#include <iterator>
#include <iostream>
#include <algorithm>
int main()
{
std::string s = "Hello,How,Are,You,Today";
std::vector<std::string> v;
std::istringstream buf(s);
for(std::string token; getline(buf, token, ','); )
v.push_back(token);
copy(v.begin(), v.end(), std::ostream_iterator<std::string>(std::cout, "."));
std::cout << '\n';
}
Works with: C++98

C++ allows the user to redefine what is considered whitespace. If the delimiter is whitespace, tokenization becomes effortless.

#include <string>
#include <locale>
#include <sstream>
#include <vector>
#include <iterator>
#include <iostream>
#include <algorithm>
struct comma_ws : std::ctype<char> {
static const mask* make_table() {
static std::vector<mask> v(classic_table(), classic_table() + table_size);
v[','] |= space; // comma will be classified as whitespace
return &v[0];
}
comma_ws(std::size_t refs = 0) : ctype<char>(make_table(), false, refs) {}
};
int main()
{
std::string s = "Hello,How,Are,You,Today";
std::istringstream buf(s);
buf.imbue(std::locale(buf.getloc(), new comma_ws));
std::istream_iterator<std::string> beg(buf), end;
std::vector<std::string> v(beg, end);
copy(v.begin(), v.end(), std::ostream_iterator<std::string>(std::cout, "."));
std::cout << '\n';
}
Works with: C++98
Library: boost

The boost library has multiple options for easy tokenization.

#include <string>
#include <vector>
#include <iterator>
#include <algorithm>
#include <iostream>
#include <boost/tokenizer.hpp>
int main()
{
std::string s = "Hello,How,Are,You,Today";
boost::tokenizer<> tok(s);
std::vector<std::string> v(tok.begin(), tok.end());
copy(v.begin(), v.end(), std::ostream_iterator<std::string>(std::cout, "."))
std::cout << '\n';
}

[edit] CoffeeScript

 
arr = "Hello,How,Are,You,Today".split ","
console.log arr.join "."
 

[edit] Common Lisp

There are libraries out there that handle splitting (e.g., SPLIT-SEQUENCE, and the more-general CL-PPCRE), but this is a simple one-off, too. When the words are written with write-with-periods, there is no final period after the last word.

(defun comma-split (string)
(loop for start = 0 then (1+ finish)
for finish = (position #\, string :start start)
collecting (subseq string start finish)
until (null finish)))
 
(defun write-with-periods (strings)
(format t "~{~A~^.~}" strings))

[edit] Clojure

Using native Clojure functions and Java Interop:

(apply str (interpose "." (.split #"," "Hello,How,Are,You,Today")))

Using the clojure.string library:

(clojure.string/join "." (clojure.string/split "Hello,How,Are,You,Today" #","))

[edit] D

import std.stdio, std.string;
 
void main() {
"Hello,How,Are,You,Today".split(",").join(".").writeln();
}
Output:
Hello.How.Are.You.Today

[edit] Delphi

 
program TokenizeString;
 
{$APPTYPE CONSOLE}
 
uses
Classes;
 
var
tmp: TStringList;
i: Integer;
 
begin
 
// Instantiate TStringList class
tmp := TStringList.Create;
try
{ Use the TStringList's CommaText property to get/set
all the strings in a single comma-delimited string }

tmp.CommaText := 'Hello,How,Are,You,Today';
 
{ Now loop through the TStringList and display each
token on the console }

for i := 0 to Pred(tmp.Count) do
Writeln(tmp[i]);
 
finally
tmp.Free;
end;
 
Readln;
 
end.
 

The result is:

 
Hello
How
Are
You
Today
 

[edit] Déjà Vu

!print join "." split "Hello,How,Are,You,Today" ","
Output:
Hello.How.Are.You.Today

[edit] E

".".rjoin("Hello,How,Are,You,Today".split(","))

[edit] Erlang

-module(tok).
-export([start/0]).
 
start() ->
Lst = string:tokens("Hello,How,Are,You,Today",","),
io:fwrite("~s~n", [string:join(Lst,".")]),
ok.

[edit] Euphoria

function split(sequence s, integer c)
sequence out
integer first, delim
out = {}
first = 1
while first<=length(s) do
delim = find_from(c,s,first)
if delim = 0 then
delim = length(s)+1
end if
out = append(out,s[first..delim-1])
first = delim + 1
end while
return out
end function
 
sequence s
s = split("Hello,How,Are,You,Today", ',')
 
for i = 1 to length(s) do
puts(1, s[i] & ',')
end for


[edit] F#

System.String.Join(".", "Hello,How,Are,You,Today".Split(','))

[edit] Factor

"Hello,How,Are,You,Today" "," split "." join print

[edit] Fantom

A string can be split on a given character, returning a list of the intervening strings.

 
class Main
{
public static Void main ()
{
str := "Hello,How,Are,You,Today"
words := str.split(',')
words.each |Str word|
{
echo ("${word}. ")
}
}
}
 

[edit] Forth

There is no standard string split routine, but it is easily written. The results are saved temporarily to the dictionary.

: split ( str len separator len -- tokens count )
here >r 2swap
begin
2dup 2, \ save this token ( addr len )
2over search \ find next separator
while
dup negate here 2 cells - +! \ adjust last token length
2over nip /string \ start next search past separator
repeat
2drop 2drop
r> here over - ( tokens length )
dup negate allot \ reclaim dictionary
2 cells / ; \ turn byte length into token count
 
: .tokens ( tokens count -- )
1 ?do dup 2@ type ." ." cell+ cell+ loop 2@ type ;
 
s" Hello,How,Are,You,Today" s" ," split .tokens \ Hello.How.Are.You.Today

[edit] Fortran

Works with: Fortran version 90 and later
PROGRAM Example
 
CHARACTER(23) :: str = "Hello,How,Are,You,Today"
CHARACTER(5) :: word(5)
INTEGER :: pos1 = 1, pos2, n = 0, i
 
DO
pos2 = INDEX(str(pos1:), ",")
IF (pos2 == 0) THEN
n = n + 1
word(n) = str(pos1:)
EXIT
END IF
n = n + 1
word(n) = str(pos1:pos1+pos2-2)
pos1 = pos2+pos1
END DO
 
DO i = 1, n
WRITE(*,"(2A)", ADVANCE="NO") TRIM(word(i)), "."
END DO
 
END PROGRAM Example

[edit] Frink

 
println[join[".", split[",", "Hello,How,Are,You,Today"]]]
 

[edit] GAP

SplitString("Hello,How,Are,You,Today", ",");
# [ "Hello", "How", "Are", "You", "Today" ]
 
JoinStringsWithSeparator(last, ".");
# "Hello.How.Are.You.Today"

[edit] Go

package main
 
import (
"fmt"
"strings"
)
 
func main() {
s := "Hello,How,Are,You,Today"
fmt.Println(strings.Join(strings.Split(s, ","), "."))
}

[edit] Groovy

println 'Hello,How,Are,You,Today'.split(',').join('.')

[edit] Haskell

The necessary operations are unfortunately not in the standard library (yet), but simple to write:

splitBy :: (a -> Bool) -> [a] -> [[a]]
splitBy _ [] = []
splitBy f list = first : splitBy f (dropWhile f rest) where
(first, rest) = break f list
 
splitRegex :: Regex -> String -> [String]
 
joinWith :: [a] -> [[a]] -> [a]
joinWith d xs = concat $ List.intersperse d xs
-- "concat $ intersperse" can be replaced with "intercalate" from the Data.List in GHC 6.8 and later
 
putStrLn $ joinWith "." $ splitBy (== ',') $ "Hello,How,Are,You,Today"
 
-- using regular expression to split:
import Text.Regex
putStrLn $ joinWith "." $ splitRegex (mkRegex ",") $ "Hello,How,Are,You,Today"

Tokenizing can also be realized by using unfoldr and break:

*Main> mapM_ putStrLn $ takeWhile (not.null) $ unfoldr (Just . second(drop 1). break (==',')) "Hello,How,Are,You,Today"
Hello
How
Are
You
Today
  • You need to import the modules Data.List and Control.Arrow

As special cases, splitting / joining by white space and by newlines are provided by the Prelude functions words / unwords and lines / unlines, respectively.

[edit] HicEst

CHARACTER string="Hello,How,Are,You,Today", list
 
nWords = INDEX(string, ',', 256) + 1
maxWordLength = LEN(string) - 2*nWords
ALLOCATE(list, nWords*maxWordLength)
 
DO i = 1, nWords
EDIT(Text=string, SePaRators=',', item=i, WordEnd, CoPyto=CHAR(i, maxWordLength, list))
ENDDO
 
DO i = 1, nWords
WRITE(APPend) TRIM(CHAR(i, maxWordLength, list)), '.'
ENDDO

[edit] Icon and Unicon

procedure main()
A := []
"Hello,How,Are,You,Today" ? while put(A, 1(tab(upto(',')|0),=","))
every writes(!A,".")
write()
end

Output:

->ss
Hello.How.Are.You.
->

[edit] Io

"Hello,How,Are,You,Today" split(",") join(".") println

[edit] J

   s=: 'Hello,How,Are,You,Today'
] t=: <;._1 ',',s
+-----+---+---+---+-----+
|Hello|How|Are|You|Today|
+-----+---+---+---+-----+
 ; t,&.>'.'
Hello.How.Are.You.Today.
 
'.' (I.','=s)}s NB. two steps combined
Hello.How.Are.You.Today

Alternatively using the system library/script strings

   require 'strings'
',' splitstring s
+-----+---+---+---+-----+
|Hello|How|Are|You|Today|
+-----+---+---+---+-----+
 
'.' joinstring ',' splitstring s
Hello.How.Are.You.Today

splitstring and joinstring also work with longer "delimiters":

   '"'([ ,~ ,) '","' joinstring ',' splitstring s
"Hello","How","Are","You","Today"

But, of course, this could be solved with simple string replacement:

   rplc&',.' s
Hello.How.Are.You.Today

The task asks us to Separate the string "Hello,How,Are,You,Today" by commas into an array (or list) so that each element of it stores a different word. but for many purposes the original string is an adequate data structure. Note also that given a string, a list of "word start" indices and "word length" integers can be logically equivalent to having an "array of words" -- and, depending on implementation details may be a superior or inferior choice to some other representation. But, in current definition of this task, the concept of "word length" plays no useful role.

Note also that J provides several built-in concepts of parsing: split on leading delimiter, split on trailing delimiter, split J language words. Also, it's sometimes more efficient to append to a string than to prepend to it. So a common practice for parsing on an embedded delimiter is to append a copy of the delimiter to the string and then use the appended result:

   fn;._2 string,','

Here fn is applied to each ',' delimited substring and the results are assembled into an array.

Or, factoring out the names:

   fn ((;._2)(@(,&','))) string

[edit] Java

Works with: Java version 1.0+

There are multiple ways to tokenize a String in Java.

The first is by splitting the String into an array of Strings. The separator is actually a regular expression so you could do very powerful things with this, but make sure to escape any characters with special meaning in regex.

Works with: Java version 1.4+
String toTokenize = "Hello,How,Are,You,Today";
 
String words[] = toTokenize.split(",");//splits on one comma, multiple commas yield multiple splits
//toTokenize.split(",+") if you want to ignore empty fields
for(int i=0; i<words.length; i++) {
System.out.print(words[i] + ".");
}

The other way is to use StringTokenizer. It will skip any empty tokens. So if two commas are given in line, there will be an empty string in the array given by the split function, but no empty string with the StringTokenizer object. This method takes more code to use, but allows you to get tokens incrementally instead of all at once.

Works with: Java version 1.0+
String toTokenize = "Hello,How,Are,You,Today";
 
StringTokenizer tokenizer = new StringTokenizer(toTokenize, ",");
while(tokenizer.hasMoreTokens()) {
System.out.print(tokenizer.nextToken() + ".");
}

[edit] JavaScript

Works with: Firefox version 2.0
alert( "Hello,How,Are,You,Today".split(",").join(".") );

[edit] LabVIEW

To tokenize the string, we use the Search/Split String function to split the string by its first comma. Add the beginning (up to, but not including the comma) to the end of the array, remove the first comma from the rest of the string, and pass it back through the shift register to the loop's next iteration. This is repeated until the string is empty. Printing is a simple matter of concatenation.
This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.
LabVIEW Tokenize a string.png

[edit] Lang5

'Hello,How,Are,You,Today ', split '. join .

[edit]

Works with: UCB Logo
to split :str :sep
output parse map [ifelse ? = :sep ["| |] [?]] :str
end

This form is more robust, doing the right thing if there are embedded spaces.

to split :str :by [:acc []] [:w "||]
if empty? :str [output lput :w :acc]
ifelse equal? first :str :by ~
[output (split butfirst :str :by lput :w :acc)] ~
[output (split butfirst :str :by  :acc lput first :str :w)]
end
? show split "Hello,How,Are,You,Today ",
[Hello How Are You Today]

[edit] Logtalk

Using Logtalk built-in support for Definite Clause Grammars (DCGs) and representing the strings as atoms for readbility:

 
:- object(spliting).
 
:- public(convert/2).
:- mode(convert(+atom, -atom), one).
 
convert(StringIn, StringOut) :-
atom_chars(StringIn, CharactersIn),
phrase(split(',', Tokens), CharactersIn),
phrase(split('.', Tokens), CharactersOut),
atom_chars(StringOut, CharactersOut).
 
split(Separator, [t([Character| Characters])| Tokens]) -->
[Character], {Character \== Separator}, split(Separator, [t(Characters)| Tokens]).
split(Separator, [t([])| Tokens]) -->
[Separator], split(Separator, Tokens).
split(_, [t([])]) -->
[].
% the look-ahead in the next rule prevents adding a spurious separator at the end
split(_, []), [Character] -->
[Character].
 
:- end_object.
 

Output:

 
| ?- spliting::convert('Hello,How,Are,You,Today', Converted).
Converted = 'Hello.How.Are.You.Today'
yes
 

[edit] Lua

require"re"
 
record = re.compile[[
record <- ( <field> (',' <field>)* ) -> {} (%nl / !.)
field <- <escaped> / <nonescaped>
nonescaped <- { [^,"%nl]* }
escaped <- '"
' {~ ([^"] / '""' -> '"')* ~} '"'
]]
 
print(unpack(record:match"hello,how,are,you,today"))

A different solution using the string-library of Lua: (skips empty columns)

str = "Hello,How,Are,You,Today" 
 
tokens = {}
for w in string.gmatch( str, "(%a+)" ) do
tokens[#tokens+1] = w
end
 
for i = 1, #tokens do
print( tokens[i] )
end

e.g. to split a string with a delimiter of | AND allowing for empty values: (NOTE: This can probably be cleaned up)

str = "Hello|How|Are|You||Today" 
 
tokens = {}
for w in string.gmatch( str, "([^|]*)|?" ) do
tokens[#tokens+1] = w
end
table.remove(tokens)--pops off the last empty value, because without doing |? we lose the last element.
 
for i = 1, #tokens do
print( tokens[i] )
end

[edit] M4

define(`s',`Hello,How,Are,You,Today')
define(`set',`define(`$1[$2]',`$3')')
define(`get',`defn($1[$2])')
define(`n',0)
define(`fill',
`set(a,n,$1)`'define(`n',incr(n))`'ifelse(eval($#>1),1,`fill(shift($@))')')
fill(s)
define(`j',0)
define(`show',
`ifelse(eval(j<n),1,`get(a,j).`'define(`j',incr(j))`'show')')
show

Output:

Hello.How.Are.You.Today.

[edit] Mathematica

Row[Riffle[StringSplit["Hello,How,Are,You,Today", ","], "."]]

[edit] MATLAB / Octave

function tokenizeString(string,delimeter)
 
tokens = {};
 
while not(isempty(string))
[tokens{end+1},string] = strtok(string,delimeter);
end
 
for i = (1:numel(tokens)-1)
fprintf([tokens{i} '.'])
end
 
fprintf([tokens{end} '\n'])
end

Output:

>> tokenizeString('Hello,How,Are,You,Today',',')
Hello.How.Are.You.Today

[edit] Maxima

l: split("Hello,How,Are,You,Today", ",")$
printf(true, "~{~a~^.~}~%", l)$

[edit] MAXScript

output = ""
for word in (filterString "Hello,How,Are,You,Today" ",") do
(
output += (word + ".")
)
format "%\n" output

[edit] Mercury

 
:- module string_tokenize.
:- interface.
 
:- import_module io.
:- pred main(io::di, io::uo) is det.
 
:- implementation.
:- import_module list, string.
 
main(!IO) :-
Tokens = string.split_at_char((','), "Hello,How,Are,You,Today"),
io.write_list(Tokens, ".", io.write_string, !IO),
io.nl(!IO).

[edit] MMIX

sep	IS	','
EOS IS 0
NL IS 10

// main registers

p IS $255
tp GREG
c GREG
t GREG
 
LOC Data_Segment
GREG @
Text BYTE "Hello,How,Are,You,Today",EOS
token BYTE 0
eot IS @+255
 
LOC #100 % main () {
Main LDA p,Text %
LDA tp,token % initialize pointers
2H LDBU c,p % DO get char
BZ c,5F % break if char == EOS
CMP t,c,sep % if char != sep then
PBNZ t,3F % store char
SET t,NL % terminate token with NL,EOS
STBU t,tp
SET t,EOS
INCL tp,1
STBU t,tp
JMP 4F % continue
 
3H STBU c,tp % store char
4H INCL tp,1 % update pointers
INCL p,1
JMP 2B % LOOP
 
5H SET t,NL % terminate last token and buffer
STBU t,tp
SET t,EOS
INCL tp,1
STBU t,tp
% next part is not really necessary
% program runs only once
% INCL tp,1 % terminate buffer
% STBU t,tp
 
LDA tp,token % reset token pointer
% REPEAT
2H ADD p,tp,0 % start of token
TRAP 0,Fputs,StdOut % output token
ADD tp,tp,p
INCL tp,1 % step to next token
LDBU t,tp
PBNZ t,2B % UNTIL EOB(uffer)
TRAP 0,Halt,0

Output:

~/MIX/MMIX/Progs> mmix tokenizing
Hello
How
Are
You
Today

[edit] Modula-3

MODULE Tokenize EXPORTS Main;
 
IMPORT IO, TextConv;
 
TYPE Texts = REF ARRAY OF TEXT;
 
VAR tokens: Texts;
string := "Hello,How,Are,You,Today";
sep := SET OF CHAR {','};
 
BEGIN
tokens := NEW(Texts, TextConv.ExplodedSize(string, sep));
TextConv.Explode(string, tokens^, sep);
FOR i := FIRST(tokens^) TO LAST(tokens^) DO
IO.Put(tokens[i] & ".");
END;
IO.Put("\n");
END Tokenize.

[edit] MUMPS

TOKENS
NEW I,J,INP
SET INP="Hello,how,are,you,today"
NEW I FOR I=1:1:$LENGTH(INP,",") SET INP(I)=$PIECE(INP,",",I)
NEW J FOR J=1:1:I WRITE INP(J) WRITE:J'=I "."
KILL I,J,INP // Kill is optional. "New" variables automatically are killed on "Quit"
QUIT

In use:

USER>D TOKENS^ROSETTA
Hello.how.are.you.today

[edit] Nemerle

using System;
using System.Console;
using Nemerle.Utility.NString;
 
module Tokenize
{
Main() : void
{
def cswords = "Hello,How,Are,You,Today";
WriteLine(Concat(".", $[s | s in cswords.Split(',')]));
// Split() produces an array while Concat() consumes a list
// a quick in place list comprehension takes care of that
}
}

[edit] NetRexx

/*NetRexx program *****************************************************
* 20.08.2012 Walter Pachl derived from REXX Version 3
**********************************************************************/

sss='Hello,How,Are,You,Today'
Say 'input string='sss
Say ''
Say 'Words in the string:'
ss =sss.translate(' ',',')
Loop i=1 To ss.words()
Say ss.word(i)'.'
End
Say 'End-of-list.'

Output as in REXX version

[edit] Nimrod

import strutils
 
let text = "Hello,How,Are,You,Today"
let tokens = text.split(',')
echo tokens.join(" ")

[edit] Objeck

 
bundle Default {
class Parse {
function : Main(args : String[]) ~ Nil {
tokens := "Hello,How,Are,You,Today"->Split(",");
each(i : tokens) {
tokens[i]->PrintLine();
};
}
}
}
 

[edit] Objective-C

Works with: GNUstep
Works with: Cocoa
NSString *text = @"Hello,How,Are,You,Today";
NSArray *tokens = [text componentsSeparatedByString:@","];
NSString *result = [tokens componentsJoinedByString:@"."];
NSLog(result);

[edit] OCaml

To split on a single-character separator:

let rec split_char sep str =
try
let i = String.index str sep in
String.sub str 0 i ::
split_char sep (String.sub str (i+1) (String.length str - i - 1))
with Not_found ->
[str]

Or the tail-recursive equivalent:

(* [try .. with] structures break tail-recursion,
so we externalise it in a sub-function *)

let string_index str c =
try Some(String.index str c)
with Not_found -> None
 
let split_char sep str =
let rec aux acc str =
match string_index str sep with
| Some i ->
let this = String.sub str 0 i
and next = String.sub str (i+1) (String.length str - i - 1) in
aux (this::acc) next
| None ->
List.rev(str::acc)
in
aux [] str
;;

But both of these will process extraneous String.sub (so one string alloc) to generate the "rest of the string" each time to pass to the next call. For N tokens there will be (N - 2) unneeded allocs. To resolve this here is a version which keeps track of the index in the string we will look next:

let split_char sep str =
let string_index_from i =
try Some (String.index_from str i sep)
with Not_found -> None
in
let rec aux i acc = match string_index_from i with
| Some i' ->
let w = String.sub str i (i' - i) in
aux (succ i') (w::acc)
| None ->
let w = String.sub str i (String.length str - i) in
List.rev (w::acc)
in
aux 0 []

Splitting on a string separator using the regular expressions library:

#load "str.cma";;
let split_str sep str =
Str.split (Str.regexp_string sep) str

There is already a library function for joining:

String.concat sep strings

[edit] OpenEdge/Progress

FUNCTION tokenizeString RETURNS CHAR (
i_c AS CHAR
):
 
DEF VAR ii AS INT.
DEF VAR carray AS CHAR EXTENT.
DEF VAR cresult AS CHAR.
 
EXTENT( carray ) = NUM-ENTRIES( i_c ).
 
DO ii = 1 TO NUM-ENTRIES( i_c ):
carray[ ii ] = ENTRY( ii, i_c ).
END.
 
DO ii = 1 TO EXTENT( carray ).
cresult = cresult + "." + carray[ ii ].
END.
RETURN SUBSTRING( cresult, 2 ).
 
END FUNCTION. /* tokenizeString */
 
MESSAGE
tokenizeString( "Hello,How,Are,You,Today" )
VIEW-AS ALERT-BOX.

Output:

---------------------------
Message
---------------------------
Hello.How.Are.You.Today
---------------------------
OK   
---------------------------

[edit] Oz

for T in {String.tokens "Hello,How,Are,You,Today" &,} do
{System.printInfo T#"."}
end

[edit] Pascal

Works with: Free_Pascal
program TokenizeString;
 
{$mode objfpc}{$H+}
 
uses
SysUtils, Classes;
const
TestString = 'Hello,How,Are,You,Today';
var
Tokens: TStringList;
I: Integer;
begin
// Uses FCL facilities, "harder" algorithm not implemented
Tokens := TStringList.Create;
try
Tokens.Delimiter := ',';
Tokens.DelimitedText := TestString;
Tokens.Delimiter := '.'; // For example
// To standard Output
WriteLn(Format('Tokenize from: "%s"', [TestString]));
WriteLn(Format('to: "%s"',[Tokens.DelimitedText]));
finally
Tokens.Free;
end;
end.

The result is:

Tokenize from: "Hello,How,Are,You,Today"
to:            "Hello.How.Are.You.Today"

[edit] Perl

print join('.', split /,/, 'Hello,How,Are,You,Today'), "\n";

CLI one-liner form:

echo "Hello,How,Are,You,Today" | perl -aplF/,/ -e '$" = "."; $_ = "@F";'

which is a compact way of telling Perl to do

BEGIN { $/ = "\n"; $\ = "\n"; }
LINE: while (defined($_ = <ARGV>)) {
chomp $_;
our(@F) = split(/,/, $_, 0);
$" = '.';
$_ = "@F";
}
continue {
die "-p destination: $!\n" unless print $_;
}

[edit] Perl 6

Works with: Rakudo version #22 "Thousand Oaks"
'Hello,How,Are,You,Today'.split(',').join('.').say;

Or with function calls:

say join '.', split ',', 'Hello,How,Are,You,Today';

[edit] PHP

Works with: PHP version 5.x
<?php
$str = 'Hello,How,Are,You,Today';
echo implode('.', explode(',', $str));
?>

[edit] PicoLisp

(mapcar pack
(split (chop "Hello,How,Are,You,Today") ",") )

[edit] Pike

("Hello,How,Are,You,Today" / ",") * ".";

[edit] PL/I

 
declare s character (100) initial ('Hello,How,Are,You,Today');
declare n fixed binary (31);
 
n = tally(s, ',')+1;
 
begin;
declare table(n) character (50) varying;
declare c character (1);
declare (i, k) fixed binary (31);
 
table = ''; k = 1;
do i = 1 to length(s);
c = substr(s, i, 1);
if c = ',' then k = k + 1;
else table(k) = table(k) || c;
end;
 
/* display the table */
table = table || '.';
put skip list (string(table));
end;
 

[edit] Pop11

The natural solution in Pop11 uses lists.

There are built in libraries for tokenising strings, illustrated below, along with code that the user could create for the task.

First show the use of sysparse_string to break up a string and make a list of strings.

;;; Make a list of strings from a string using space as separator
lvars list;
sysparse_string('the cat sat on the mat') -> list;
;;; print the list of strings
list =>
** [the cat sat on the mat]

By giving it an extra parameter 'true' we can make it recognize numbers and produce a list of strings and numbers

lvars list;
sysparse_string('one 1 two 2 three 3 four 4', true) -> list;
;;; print the list of strings and numbers
list =>
** [one 1 two 2 three 3 four 4]
;;; check that first item is a string and second an integer
isstring(list(1))=>
** <true>
isinteger(list(2))=>
** <true>

Now show some uses of the built in procedure sys_parse_string, which allows more options:

;;; Make pop-11 print strings with quotes
true -> pop_pr_quotes;
;;;
;;; Create a string of tokens using comma as token separator
lvars str='Hello,How,Are,You,Today';
;;;
;;; Make a list of strings by applying sys_parse_string
;;; to str, using the character `,` as separator (the default
;;; separator, if none is provided, is the space character).
lvars strings;
[% sys_parse_string(str, `,`) %] -> strings;
;;;
;;; print the list of strings
strings =>
** ['Hello' 'How' 'Are' 'You' 'Today']

If {% ... %} were used instead of [% ... %] the result would be a vector (i.e. array) of strings rather than a list of strings.

{% sys_parse_string(str, `,`) %} -> strings;
;;; print the vector
strings =>
** {'Hello' 'How' 'Are' 'You' 'Today'}

It is also possible to give sys_parse_string a 'conversion' procedure, which is applied to each of the tokens. E.g. it could be used to produce a vector of numbers, using the conversion procedure 'strnumber', which converts a string to a number:

lvars numbers;
{% sys_parse_string('100 101 102 103 99.9 99.999', strnumber) %} -> numbers;
;;; the result is a vector containing integers and floats,
;;; which can be printed thus:
numbers =>
** {100 101 102 103 99.9 99.999}

Using lower level pop-11 facilities to tokenise the string:

;;; Declare and initialize variables
lvars str='Hello,How,Are,You,Today';
;;; Iterate over string
lvars ls = [], i, j = 1;
for i from 1 to length(str) do
 ;;; If comma
if str(i) = `,` then
 ;;; Prepend word (substring) to list
cons(substring(j, i - j, str), ls) -> ls;
i + 1 -> j;
endif;
endfor;
;;; Prepend final word (if needed)
if j <= length(str) then
cons(substring(j, length(str) - j + 1, str), ls) -> ls;
endif;
;;; Reverse the list
rev(ls) -> ls;

Since the task requires to use array we convert list to array

;;; Put list elements and lenght on the stack
destlist(ls);
;;; Build a vector from them
lvars ar = consvector();
;;; Display in a loop, putting trailing period
for i from 1 to length(ar) do
printf(ar(i), '%s.');
endfor;
printf('\n');

We could use list directly for printing:

for i in ls do
printf(i, '%s.');
endfor;

so the conversion to vector is purely to satisfy task formulation.

[edit] PowerShell

Works with: PowerShell version 1
$words = "Hello,How,Are,You,Today".Split(',')
[string]::Join('.', $words)
Works with: PowerShell version 2
$words = "Hello,How,Are,You,Today" -split ','
$words -join '.'


[edit] Prolog

Works with: SWI Prolog
splitup(Sep,[token(B)|BL]) --> splitup(Sep,B,BL).
splitup(Sep,[A|AL],B) --> [A], {\+ [A] = Sep }, splitup(Sep,AL,B).
splitup(Sep,[],[B|BL]) --> Sep, splitup(Sep,B,BL).
splitup(_Sep,[],[]) --> [].
start :-
phrase(splitup(",",Tokens),"Hello,How,Are,You,Today"),
phrase(splitup(".",Tokens),Backtogether),
string_to_list(ABack,Backtogether),
writeln(ABack).

Output:

?- start.
Hello.How.Are.You.Today

[edit] Python

Works with: Python version 2.5
Works with: Python version 3.0
text = "Hello,How,Are,You,Today"
tokens = text.split(',')
print ('.'.join(tokens))

Or if interpretation of the task description means you don't need to keep an intermediate array:

print ('.'.join('Hello,How,Are,You,Today'.split(',')))

[edit] R

text <- "Hello,How,Are,You,Today"
junk <- strsplit(text, split=",")
print(paste(unlist(junk), collapse="."))

or the one liner

paste(unlist(strsplit(text, split=",")), collapse=".")

[edit] Racket

 
#lang racket
(string-join (string-split "Hello,How,Are,You,Today" ",") ".")
;; -> "Hello.How.Are.You.Today"
 

[edit] Raven

'Hello,How,Are,You,Today' ',' split '.' join print

[edit] REBOL

print ["Original:"  original: "Hello,How,Are,You,Today"]
tokens: parse original ","
dotted: "" repeat i tokens [append dotted rejoin [i "."]]
print ["Dotted: " dotted]

Output:

Original: Hello,How,Are,You,Today
Dotted:   Hello.How.Are.You.Today.

[edit] Retro

{{
 : char ( -$ ) " " ;
 : tokenize ( $-$$ )
@char ^strings'splitAtChar withLength 1- over + 0 swap ! tempString ;
 : action ( $- )
keepString ^buffer'add ;
---reveal---
 : split ( $cb- )
^buffer'set !char
char ^strings'append
[ tokenize action dup 1 <> ] while drop
^buffer'get drop ;
}}

This will suffice to split a string into an array of substrings. It is used like this:

create strings 100 allot
"Hello,How,Are,You,Today" ', strings split

Since the buffer' vocabulary creates a zero-terminated buffer, we can display it using the each@ combinator and a simple quote:

strings [ @ "%s." puts ] ^types'STRING each@

[edit] REXX

[edit] version 1

This REXX version doesn't append a period to the last word in the list.

/*REXX program seperates a string of comma-delimited words, and echoes. */
sss = 'Hello,How,Are,You,Today' /*words seperated by commas (,). */
say 'input string =' sss /*display the original string. */
new=sss /*make a copy of the string. */
/* [↓] string NEW is destroyed. */
do items=1 until new=='' /*keep going until NEW is empty.*/
parse var new a.items ',' new /*parse words delinated by comma.*/
end /*items*/ /* [↑] the array is named A. */
 
say; say 'Words in the string:' /*display a header for the list. */
 
do j=1 for items /*now, display all the words. */
say a.j || left('.', j\==items) /*append period to word, maybe. */
end /*j*/ /* [↑] don't append "." if last.*/
 
say 'End-of-list.' /*display a trailer for the list.*/
/*stick a fork in it, we're done.*/

output

input string = Hello,How,Are,You,Today
 
Words in the string:
Hello.
How.
Are.
You.
Today
End-of-list.

[edit] version 2

/*REXX program to separate a string of comma-delimited words and echo */
sss='Hello,How,Are,You,Today'
say 'input string='sss
say ''
say 'Words in the string:'
ss =translate(sss,' ',',')
Do i=1 To words(ss)
say word(ss,i)'.'
End
say 'End-of-list.'

output is identical to Version 1.

[edit] Ruby

puts "Hello,How,Are,You,Today".split(',').join('.')

[edit] Scala

println("Hello,How,Are,You,Today" split "," mkString ".")

[edit] Scheme

Works with: Guile
(use-modules (ice-9 regex))
(define s "Hello,How,Are,You,Today")
(define words (map match:substring (list-matches "[^,]+" s)))
 
(do ((n 0 (+ n 1))) ((= n (length words)))
(display (list-ref words n))
(if (< n (- (length words) 1))
(display ".")))

(with SRFI 13)

(define s "Hello,How,Are,You,Today")
(define words (string-tokenize s (char-set-complement (char-set #\,))))
(define t (string-join words "."))

[edit] Seed7

var array string: tokens is 0 times "";
 
tokens := split("Hello,How,Are,You,Today", ",");

[edit] Slate

('Hello,How,Are,You,Today' splitWith: $,) join &separator: '.'.

[edit] Smalltalk

|array |
array := 'Hello,How,Are,You,Today' subStrings: $,.
array fold: [:concatenation :string | concatenation, '.', string ]

Some implementations also have a join: convenience method that allows the following shorter solution:

('Hello,How,Are,You,Today' subStrings: $,) join: '.'

The solution displaying a trailing period would be:

|array |
array := 'Hello,How,Are,You,Today' subStrings: $,.
array inject: '' into: [:concatenation :string | concatenation, string, '.' ]

[edit] SNOBOL4

For this task, it's convenient to define Perl-style split( ) and join( ) functions.

        define('split(chs,str)i,j,t,w2') :(split_end)
split t = table()
sp1 str pos(0) (break(chs) | rem) $ t<i = i + 1>
+ span(chs) (break(chs) | '') . w2 = w2 :s(sp1)
* t<i> = differ(str,'') str ;* Uncomment for CSnobol
split = array(i)
sp2 split<j = j + 1> = t<j> :s(sp2)f(return)
split_end
 
define('join(ch,a)i,') :(join_end)
join join = join a<i = i + 1>
join = join ?a<i + 1> ch :s(join)f(return)
join_end
 
* # Test and display
output = join('.',split(',','Hello,How,Are,You,Today'))
end

Output:

Hello.How.Are.You.Today

[edit] Standard ML

val splitter = String.tokens (fn c => c = #",");
val main = (String.concatWith ".") o splitter;

Test:

- main "Hello,How,Are,You,Today"
val it = "Hello.How.Are.You.Today" : string

[edit] Swift

let text = "Hello,How,Are,You,Today"
let tokens = split(text, { $0 == "," }) // for single-character separator
println(tokens)
let result = ".".join(tokens)
println(result)

[edit] Tcl

Generating a list form a string by splitting on a comma:

split $string ","

Joining the elements of a list by a period:

join $list "."

Thus the whole thing would look like this:

puts [join [split "Hello,How,Are,You,Today" ","] "."]

If you'd like to retain the list in a variable with the name "words", it would only be marginally more complex:

puts [join [set words [split "Hello,How,Are,You,Today" ","]] "."]

(In general, the regexp command is also used in Tcl for tokenization of strings, but this example does not need that level of complexity.)

[edit] tr

tr knows nothing about arrays, so this solution only changes each comma to a period.

echo 'Hello,How,Are,You,Today' | tr ',' '.'

[edit] TUSCRIPT

 
$$ MODE TUSCRIPT
SET string="Hello,How,Are,You,Today"
SET string=SPLIT (string,":,:")
SET string=JOIN (string,".")
 

[edit] TXR

Collecting tokens which consist of non-empty sequences of non-commas.

@(next :list "Hello,How,Are,You,Today")
@(coll)@{token /[^,]+/}@(end)
@(output)
@(rep)@token.@(last)@token@(end)
@(end)

Different approach. Collect tokens, each of which is a piece of text which either terminates before a comma, or else extends to the end of the line.

@(next :list "Hello,How,Are,You,Today")
@(coll)@(maybe)@token,@(or)@token@(end)@(end)
@(output)
@(rep)@token.@(last)@token@(end)
@(end)

Using TXR Lisp:

txr -p '(cat-str (split-str "Hello,How,Are,You,Today" ",") ".")'
Hello.How.Are.You.Today

[edit] UNIX Shell

Works with: Bourne Shell
string='Hello,How,Are,You,Today'
 
(IFS=,
printf '%s.' $string
echo)

Works with: Bourne Again SHell
Works with: Public Domain Korn SHell version 5.2.14
#! /bin/bash
stripchar-l ()
#removes the specified character from the left side of the string
#USAGE: stripchar "stuff" "s" --> tuff
{
string="$1";
string=${string#"$2"};
 
echo "$string"
}
 
join ()
#join a string of characters on a specified delimiter
#USAGE: join "1;2;3;4" ";" "," --> 1,2,3,4
{
local result="";
local list="$1";
OLDIFS="$IFS";
local IFS=${2-" "};
local output_field_seperator=${3-" "};
 
for element in $list;
do
result="$result$output_field_seperator$element";
done;
 
result="`stripchar-l "$result" "$output_field_seperator"`";
echo "$result";
IFS="$OLDIFS"
}
 
split ()
{
#split a string of characters on a specified delimiter
#USAGE: split "1;2;3;4" ";" --> 1 2 3 4
local list="$1";
local input_field_seperator=${2-" "};
local output_field_seperator=" ";
 
#defined in terms of join
join "$list" "$input_field_seperator" "$output_field_seperator"
}
 
strtokenize ()
{
#splits up a string of characters into tokens,
#based on a user supplied delimiter
#USAGE:strtokenize "1;2;3;4" ";" ":" --> 1:2:3:4
local list="$1";
local input_delimiter=${2-" "};
local output_delimiter=${3-" "};
local contains_a_space=" "; #added to highlight the use
#of " " as an argument to join
 
#splits it input then joins it with a user supplied delimiter
join "$( split "$list" "$input_delimiter" )" \
"$contains_a_space" "$output_delimiter";
}

Example

 strtokenize "Hello,How,Are,You,Today" "," "." 
Hello.How.Are.You.Today

[edit] UnixPipes

Works with: Bourne Shell
token() {
(IFS=, read -r A B; echo "$A".; test -n "$B" && (echo "$B" | token))
}
 
echo "Hello,How,Are,You" | token

[edit] Ursala

A list of strings is made by separating at the commas using the library function, sep. A single string is then made by joining the list of strings with periods using the library function, mat. Each of these is a second order function parameterized by the delimiter. Character literals are preceded by a backquote.

#import std
 
token_list = sep`, 'Hello,How,Are,You,Today'
 
#cast %s
 
main = mat`. token_list

Output:

'Hello.How.Are.You.Today'

[edit] Vala

// declare test string
string s = "Hello,How,Are,You,Today";
// create array of strings, could use var words instead if desired
string[] words = s.split(",");
// create string by joining array of strings with .
string joined = string.joinv(".", words);

[edit] Vedit macro language

Vedit does not use the concepts of array or list. Normally, the text is processed as text in an edit buffer.

However, this example shows how to split the text into multiple text registers (10, 11, 12 etc.). The contents of each text register is then displayed to user, separated by a period.

Buf_Switch(Buf_Free)
Ins_Text("Hello,How,Are,You,Today")
 
// Split the text into text registers 10, 11, ...
BOF
#1 = 9
Repeat(ALL) {
#1++
#2 = Cur_Pos
Search(",", ADVANCE+ERRBREAK)
Reg_Copy_Block(#1, #2, Cur_Pos-1)
}
Reg_Copy_Block(#1, #2, EOB_Pos)
 
// Display the list
for (#3 = 10; #3 <= #1; #3++) {
Reg_Type(#3) Message(".")
}
 
Buf_Quit(OK)

[edit] Wortel

@join "." @split "," "Hello,How,Are,You,Today"

Returns

"Hello.How.Are.You.Today"

[edit] XPL0

string 0;
include c:\cxpl\codes;
int I, J, K, Char;
char String, Array(5,6); \5 words and 5 maximum chars + terminating 0
 
[String:= "Hello,How,Are,You,Today";
I:= 0; K:= 0;
repeat J:= 0;
loop [Char:= String(I);
I:= I+1;
if Char=^, or Char=0 then quit;
Array(K,J):= Char;
J:= J+1;
];
Array(K,J):= 0; \terminate word
K:= K+1; \next word in array
until K>=5;
for K:= 4 downto 0 do [Text(0, addr Array(K,0)); ChOut(0, ^.)];
CrLf(0);
]

The 'addr' operator is used to fetch the 32-bit address of Array rather than a byte from the character array.

Output (done in reverse order to emphasize the tokens are indeed separate):

Today.You.Are.How.Hello.

[edit] zkl

"Hello,How,Are,You,Today".split(",").concat(".").println();
Hello.How.Are.You.Today

[edit] Zsh

str='Hello,How,Are,You,Today'
tokens=(${(s:,:)str})
print ${(j:.:)tokens}

Or, using SH_SPLIT_WORD:

str='Hello,How,Are,You,Today'
IFS=, echo ${(j:.:)${=str}}
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox