Time for an 2014 update…

Task/Binary-strings/BASIC/binary-strings-1.basic

@@ -0,0 +1,28 @@
+REM STRING CREATION AND DESTRUCTION (WHEN NEEDED AND IF THERE'S NO GARBAGE COLLECTION OR SIMILAR MECHANISM)
+A$ = "STRING" : REM CREATION
+A$ = "" : REM DESTRUCTION
+PRINT FRE(0) : REM GARBAGE COLLECTION
+
+REM STRING ASSIGNMENT
+A$ = "STRING" : R$ = "DEUX"
+
+REM STRING COMPARISON
+PRINT A$ = B$; A$ <> B$; A$ < B$; A$ > B$; A$ <= B$; A$ >= B$
+
+REM STRING CLONING AND COPYING
+B$ = A$
+
+REM CHECK IF A STRING IS EMPTY
+PRINT LEN(A$) = 0
+
+REM APPEND A BYTE TO A STRING
+A$ = A$ + CHR$(0)
+
+REM EXTRACT A SUBSTRING FROM A STRING
+S$ = MID$(A$, 2, 3)
+
+REM REPLACE EVERY OCCURRENCE OF A BYTE (OR A STRING) IN A STRING WITH ANOTHER STRING
+S = LEN(S$) : R = LEN(R$) : A = LEN(A$) : IF A > S THEN B$ = "" : FOR I = 1 TO A : F = MID$(A$, I, S) = S$ : B$ = B$ + MID$(R$, 1, R * F) + MID$(A$, I, F = 0) : NEXT I : A$ = B$ : PRINT A$
+
+REM JOIN STRINGS
+J$ = A$ + STR$(42) + " PUDDLES " + B$ + CHR$(255) : REM USE +

Task/Binary-strings/Deja-Vu/binary-strings.djv

@@ -0,0 +1,10 @@
+local :b make-blob 10 #ten bytes of initial size
+set-to b 0 255
+!. get-from b 0 #prints 255
+!. b #prints (blob:ff000000000000000000)
+local :b2 make-blob 3
+set-to b2 0 97
+set-to b2 1 98
+set-to b2 2 99
+!. b #prints (blob:"abc")
+!. !encode!utf-8 b #prints "abc"

Task/Binary-strings/Erlang/binary-strings-1.erl

@@ -0,0 +1,49 @@
+-module(binary_string).
+-compile([export_all]).
+
+%% Erlang has very easy handling of binary strings. Using
+%% binary/bitstring syntax the various task features will be
+%% demonstrated.
+
+
+%% Erlang has GC so destruction is not shown.
+test() ->
+    Binary = <<0,1,1,2,3,5,8,13>>, % binaries can be created directly
+    io:format("Creation: ~p~n",[Binary]),
+    Copy = binary:copy(Binary), % They can also be copied
+    io:format("Copy: ~p~n",[Copy]),
+    Compared = Binary =:= Copy, % They can be compared directly
+    io:format("Equal: ~p = ~p ? ~p~n",[Binary,Copy,Compared]),
+    Empty1 = size(Binary) =:= 0, % The empty binary would have size 0
+    io:format("Empty: ~p ? ~p~n",[Binary,Empty1]),
+    Empty2 = size(<<>>) =:= 0, % The empty binary would have size 0
+    io:format("Empty: ~p ? ~p~n",[<<>>,Empty2]),
+    Substring = binary:part(Binary,3,3),
+    io:format("Substring: ~p [~b..~b] => ~p~n",[Binary,3,5,Substring]),
+    Replace = binary:replace(Binary,[<<1>>],<<42>>,[global]),
+    io:format("Replacement: ~p~n",[Replace]),
+    Append = <<Binary/binary,21>>,
+    io:format("Append: ~p~n",[Append]),
+    Join = <<Binary/binary,<<21,34,55>>/binary>>,
+    io:format("Join: ~p~n",[Join]).
+
+%% Since the task also asks that we show how these can be reproduced
+%% rather than just using BIFs, the following are some example
+%% recursive functions reimplementing some of the above.
+
+%% Empty string
+is_empty(<<>>) ->
+    true;
+is_empty(_) ->
+    false.
+
+%% Replacement:
+replace(Binary,Value,Replacement) ->
+    replace(Binary,Value,Replacement,<<>>).
+
+replace(<<>>,_,_,Acc) ->
+    Acc;
+replace(<<Value,Rest/binary>>,Value,Replacement,Acc) ->
+    replace(Rest,Value,Replacement,<< Acc/binary, Replacement >>);
+replace(<<Keep,Rest/binary>>,Value,Replacement,Acc) ->
+    replace(Rest,Value,Replacement,<< Acc/binary, Keep >>).

Task/Binary-strings/Erlang/binary-strings-2.erl

@@ -0,0 +1,10 @@
+215> binary_string:test().
+Creation: <<0,1,1,2,3,5,8,13>>
+Copy: <<0,1,1,2,3,5,8,13>>
+Equal: <<0,1,1,2,3,5,8,13>> = <<0,1,1,2,3,5,8,13>> ? true
+Empty: <<0,1,1,2,3,5,8,13>> ? false
+Empty: <<>> ? true
+Substring: <<0,1,1,2,3,5,8,13>> [3..5] => <<2,3,5>>
+Replacement: <<0,42,42,2,3,5,8,13>>
+Append: <<0,1,1,2,3,5,8,13,21>>
+Join: <<0,1,1,2,3,5,8,13,21,34,55>>