13[2-8]

[root@han learn_erl]# cat numberconvert2.erl 
-module(numberconvert2).
-compile(export_all).

binary_to_charlist(_, Postion, Result, TotalLength) when Postion =:= TotalLength ->
   lists:reverse(Result);
binary_to_charlist(Str, Postion, Result, TotalLength) ->
   NewResult = [binary:part(Str, {Postion, 1})|Result],
   binary_to_charlist(Str, Postion+1, NewResult, TotalLength).

number_analysis(Prefix) ->
   NewPrefixList = binary_to_charlist(Prefix, 0, [], byte_size(Prefix)),
   NewPrefixList.

number_handle(Prefix) ->
   NewPrefix = number_analysis(Prefix),
   case lists:member(<<"[">>, NewPrefix) of
      true   -> 
         R = number_classifier(NewPrefix, [], []),
         %%io:format("======== ~p", [R]),
         case R of
             {A} -> A;
             {A,B} -> [ A1 ++ B1|| A1 <- A, B1 <- B];
             {A,B,C} -> [ A1 ++ B1++ C1 || A1 <- A, B1 <- B, C1 <- C];
             {A,B,C,D} -> [ A1 ++ B1++ C1++D1 || A1 <- A, B1 <- B, C1 <- C, D1 <- D];
             _ -> io:format("unsupported ~p", [R])
         end;
      false  -> [Prefix|[]]
   end.

number_classifier([H|Prefix], Acc, Result) when H >= <<"0">> andalso H =< <<"9">> ->
   number_classifier(Prefix, [H|Acc], Result);
number_classifier([H|Prefix], Acc, Result) when H == <<"[">> ->
   case Acc of
   [] ->
      {NewPrefix, NewResult} = number_handle_right_bracket(Prefix, [], Result),
      number_classifier(NewPrefix, [], NewResult);
   _  ->
      NewAcc = lists:reverse(Acc),
      NewAcc1 = binary_to_list(list_to_binary(NewAcc)),
      {NewPrefix, NewResult} = number_handle_right_bracket(Prefix, [], [[NewAcc1]|Result]),
      number_classifier(NewPrefix, [], NewResult)
   end;
number_classifier([], [], Result) ->
   list_to_tuple(lists:reverse(Result));
number_classifier([], Acc, Result) ->
   NewAcc = lists:reverse(Acc),
   NewAcc1 = binary_to_list(list_to_binary(NewAcc)),
   list_to_tuple(lists:reverse([[NewAcc1]|Result])).

number_handle_right_bracket([H|Prefix], Acc, Result) when H =/= <<"]">> ->
   number_handle_right_bracket(Prefix, [H|Acc], Result);
number_handle_right_bracket([H|Prefix], Acc, Result) when H == <<"]">> ->
   NewAcc = lists:reverse(Acc),
   NewAcc2 = number_handle_brackets_content(NewAcc, H, []),
   {Prefix, [NewAcc2|Result]};
number_handle_right_bracket([], Acc, Result) ->
   NewAcc = lists:reverse(Acc),
   {[], [NewAcc|Result]}.

number_handle_brackets_content([H|Tail], _Left, Acc2) when H >= <<"0">> andalso H =< <<"9">> ->
   number_handle_brackets_content(Tail, H, [binary_to_list(H)|Acc2]);
number_handle_brackets_content([H|Tail], Left, [_|Acc2]) when H == <<"-">> ->
   [Right|Tail1] = Tail,
   %%io:format("~p ~p", [Left, Right]),
   NewAcc = generate_numbers(binary_to_integer(Left), binary_to_integer(Right), Acc2),
   %%io:format("~p ", [NewAcc]),
   number_handle_brackets_content(Tail1, Right, NewAcc);
number_handle_brackets_content([H|Tail], _Left, Acc2) when H == <<",">> ->
   number_handle_brackets_content(Tail, H, Acc2);
number_handle_brackets_content([], _Left, Acc2) ->
   NewAcc2 = lists:reverse(Acc2),
   NewAcc2.

generate_numbers(Left,Right, Acc) when Left =< Right ->
   IntB = Left + 1,
   NewLeft = integer_to_list(Left),
   generate_numbers(IntB, Right, [NewLeft|Acc]);
generate_numbers(_Left,_Right, Acc) -> Acc.

217> c(numberconvert2).                                 
{ok,numberconvert2}
218> 
218> 
218> numberconvert2:number_handle(<<"[2-4]7[1-2]">>).
["271","272","371","372","471","472"]
219> 
219> 
219> numberconvert2:number_handle(<<"13[14-9][5-7]1">>).
["13151","13161","13171","13451","13461","13471","13551",
 "13561","13571","13651","13661","13671","13751","13761",
 "13771","13851","13861","13871","13951","13961","13971"]
220> 
220>