I was trying to convert a string containing only base 10 digits (e.g. "124890") to an array of corresponding integers (for given example: [1, 2, 4, 8, 9, 0]), in Ruby.
I'm curious about how easily this can be accomplished in Ruby and in other languages.
Python:
[int(c) for c in s]
or
map(int, s)
Note: In Python 3 (and later), the list-like object returned by map() is not subscriptable. If you need this capability, just convert it to a list/tuple using list(map()) or tuple(map()).
Here's my tentative in Ruby :
"124890".split(//).map {|chr| chr.to_i}
=> [1, 2, 4, 8, 9, 0]
This splits the string using a regex that matches a zero-length string so each character is an element of the array, them maps each (one-character string) element is converted to its integer value.
>> "124890".split("").map{ |i| i.to_i}
=> [1, 2, 4, 8, 9, 0]
In C#
string nums = "124890";
int[] vals = new int[nums.Length];
int i = 0;
int offset = Convert.ToInt32('0');
foreach(char d in nums)
vals[i++] = Convert.ToInt32(d) - offset;;
Updated: Fixed algorith, as noted in comments.
PHP: $string = preg_split("//", "1234567890");
That should work. Although I'm not sure if you need the regex delimiters for an empty string in preg_split. I do know that explode will NOT work as if you try to explode on the empty string, explode() returns false.
<?php
$array = str_split("124890");
?>
It's hard to beat a built-in method :)
Here's a one-liner in C#, without the fancy => stuff.
Array.ConvertAll<char, int>(s.ToCharArray(), new Converter<char, int>(delegate(char c) { return int.Parse(c.ToString()); }));
That's a crappy solution, as noted. Now I've just tried to make it worse (without adding too many meaningless function calls). Here's a one-liner with type safety!
Array.ConvertAll<char, int>(Enumerable.TakeWhile<char>(s.ToCharArray().AsEnumerable<char>(), new Func<char,bool>(delegate(char c) { int i; return int.TryParse(c.ToString(), out i); })).ToArray<char>(), new Converter<char, int>(delegate(char c) { return int.Parse(c.ToString()); }));
No code needed in PHP! You can access a string as an array and if you use the number in a numeric way then an implicit typecast will be done for you. Example:
$foo = "01234";
echo 4 - $foo[2]; // echos 2
In C:
void convert (int * array, char * string)
{
int i=0;
while (*string)
array[i++] = *(string++)-'0';
}
Just like James Curran's in C# but with one less line
string nums = "124890";
int[] vals = new int[nums.Length];
for (int i = 0; i < vals.Length; i++)
vals[i] = Convert.ToInt32(nums[i]);
In Java:
String s = "12345";
int[] nums = new int[s.length()];
for(int i = 0; i < nums.length; i++)
nums[i] = s.charAt(i) - '0';
Aaah, the sweetness of Linq. Compared to the other .NET implementations, you can see why I love it so...
int[] foo = (from x in "1234567890" select int.Parse(x.ToString())).ToArray();
For S&G's here's the fluent-style extension method version of this:
"1234567890"
.ToCharArray()
.Select(x => int.Parse(x.ToString()))
.ToArray();
In Delphi:
type
TIntArray = array of Integer;
function ConvertStringToIntArray(const aString: String): TIntArray;
var i: Integer;
begin
SetLength(Result, Length(aString));
for i := 1 to Length(aString) do
Result[i-1] := ord(aString[i]) -48;
end;
C#:
Linq really makes this task easy and Will's version can even be cut further.
from c in str select (int)(c - '0');
Or, using the extension style:
str.Select(c => (int)(c - '0'));
Or multithread it (I'll bet this is less code than any other language):
str.AsParallel().Select(c => (int)(c - '0'));
Here's a C++ version.
std::vector<int> result;
for (const char *digit = "124890"; *digit; ++digit)
result.push_back(*digit - '0');
Here's another C++ version in a more modern style. I'm not sure it's an improvement.
int ConvertDigit(char ch)
{
return ch - '0';
}
std::string digits("124890");
std::vector<int> result;
result.resize(digits.size());
std::transform(digits.begin(), digits.end(), result.begin(), ConvertDigit);
In VB.NET:
Dim source As String = "123458796"
Dim data() As Char = source.ToCharArray
Dim res(source.length - 1) As Integer
for i as integer = 0 to Source.length - 1
res(i) = cint(microsoft.visualbasic.val(data(i)))
Next
One way to do it in Icon:
thelist := [] ; every put(thelist, !"124890" + 0)
# thelist is now [1, 2, 4, 8, 9, 0]
Although if you don't really need a list of ints you can just index (from 1) the chars of the string as if they were ints - Icon is dynamically typed:
write(4 - "014890"[2]) # prints 3
It's not very succinct in VB6, but more so than VB.NET :)
foo$ = "124890"
ReDim thelist&(Len(foo$))
For i& = 1 To Len(foo$)
thelist(i&) = Mid(foo$, i&, 1)
Next
In C I wouldn't bother. :-) The "string" is already an "array" of characters, so you can iterate and manipulate it like any other array. To get the int value of a single character, just subtract '0' from the char value:
const char *myString = "12345";
int i;
for (i = 0; myString[i] != '\0'; i++) {
int myIntVal = myString[i] - '0';
printf("Integer: %d\n", myIntVal);
}
Ruby:
"123".bytes.collect { |d| d - "0"[0] }
C++, works for std::string and null terminated strings:
#include <vector>
#include <boost/foreach.hpp>
template<typename T>
std::vector<int> doit(const T& s)
{
std::vector<int> retval;
BOOST_FOREACH (char c, s) retval.push_back(c - '0');
return retval;
}
Fortran 90 allows you to use strings instead of file handles in read/write operations, which lets you do things like this:
subroutine convert(string, intArray)
character(len=*), intent(in) :: string
integer, dimension(:), intent(out) :: intArray
integer :: ii
do ii=1,len(string)
read(string(ii:ii), '(I1)') intArray(ii)
end do
end subroutine convert
Note that to get around the allocation/buffer over-run problem, I am assuming that I'm compiling this with array bounds checking enabled.
T-SQL doesn't have arrays, but you could represent it as a table
Here's a looping routine:
declare @s varchar(1000); set @s='124890';
declare @t table(i int)
declare @i int; set @i=0
while @i<len(@s) begin
set @i=@i+1;
insert @t(i) values(convert(int,substring(@s,@i,1)))
end
select * from @t
Here's a direct set-based version, but it relies on having an numbers set:
select convert(int,substring('124890',i,1)) as i from (
select 1 as i union select 2 union select 3 union select 4 union select 5 union select 6
) j
you could also use my SQL range function to do it like this:
select convert(int,substring('124890',n,1)) as i from dbo.Range(1,len('124890'),1)
In Ruby 1.9, or on 1.8 if you are in Rails/have the symbol_to_proc gem, it becomes
"124890".split('').map(&:to_i) #=> [1, 2, 4, 8, 9, 0]
Here's a Standard ML version using function composition (with output from SML/NJ):
- val digitsToString = (map (valOf o Int.fromString o Char.toString)) o explode;
val digitsToString = fn : string -> int list
- digitsToString "124890";
val it = [1,2,4,8,9,0] : int list
How does it work? The types tell almost the whole story:
- explode;
val it = fn : string -> char list
- map;
val it = fn : ('a -> 'b) -> 'a list -> 'b list
- Char.toString;
val it = fn : char -> string
- Int.fromString;
val it = fn : string -> int option
- valOf;
val it = fn : 'a option -> 'a
- valOf o Int.fromString o Char.toString;
val it = fn : char -> int
In x86 assembly, if we have a null-terminated input and a correctly-sized, pre-allocated output, we can do:
xor eax,eax
mov esi,dword ptr [source]
mov edi,dword ptr [dest]
_loop:
mov al,[esi]
test eax,0
jz _done
add esi,1
and al,0fh
mov [edi],eax
add edi,4
jmp _loop
_done:
Sure it is a lot of lines, but the whole thing is 29 bytes, so that is pretty small.
Groovy:
def s = '124890'
def list = []
s.each{ list << Integer.parseInt(it) }
Fast C implementation that does in-place replacement (since char is both a character and a number (byte)):
void toNumbers(char *digits) {
int len = strlen(digits);
char *end = digits + len;
char *next;
// Process 4 characters at a time
while ((next = digits + 4) <= end) {
*((long *)digits) -= 0x30303030;
digits = next;
}
// Handle remaining characters
switch (len & 3) {
case 3:
*((short *)digits) -= 0x3030;
digits += 2;
case 1:
*digits -= 0x30;
break;
case 2:
*((short *)digits) -= 0x3030;
}
}
JavaScript 1.6:
str.split("").map(function (d) { return parseInt(d); })
Update:
Or more concisely:
str.split("").map(Number)
Scheme:
(map
(lambda (c)
(- (char->integer c) (char->integer #\0)))
(string->list "12345"))
In XQuery:
for $c in string-to-codepoints("124890")
return xs:integer(codepoints-to-string($c))
Two versions in JavaScript:
myString.split("").map(Number)
A second version which is more concise when you amortise it over the entire length of your code base:
// During initialisation of your app
String.prototype.map = Array.prototype.map
...
// Later
myString.map(Number)
In Erlang (since strings are lists of integers) you only need to go from ASCII-value to integer value by subtracting the ASCII value of '0'. In its shortest form:
lists:map( fun(X) -> X-$0 end, "1234").
If you want a check for validity preventing conversion of non-base-10 characters and make it convenient to use:
Convert = fun(L) -> lists:map( fun(X) when is_integer(X), X>=$0, X=<$9 -> X-$0 end, L) end.
Use as:
74> Convert("10823472").
[1,0,8,2,3,4,7,2]
Now for something invalid:
75> Convert("aap").
=ERROR REPORT==== 8-Oct-2008::12:12:36 ===
Error in process with exit value: {function_clause,[{erl_eval,'-inside-a-shell-fun-',"a"},{erl_eval,expr,3}]}
** exited: {function_clause,[{erl_eval,'-inside-a-shell-fun-',"a"},
{erl_eval,expr,3}]} **
(if it fails, it fails big ;))
In idiomatic REBOL it's
nums: copy []
forall c "124890" [
append nums to-integer to-string c
]
However, one can easily create a map function in REBOL and use it for this purpose:
map: func [f [any-function!] s [series!] /local result] [
result: copy []
forall s [
append/only result f first s
]
result
]
map func [c] [to-integer to-string c] "124890"
I have to admit that this is not one of REBOL's strong points, although more advanced Rebollers than I may know an even more succinct way.
In Clojure:
(map #(new Integer (str %1)) "124890")
Oh, and while we're at it, twk asked for a multi-threaded version above. Here's one:
(pmap #(new Integer (str %1)) "124890")
In Perl, assuming valid input in $str:
@digits = split //, $str;
This works because Perl, like PHP, unifies string and numeric representation.
I bet I can multi-thread mine in less lines than your language does....
Here's Konrad Rudolph's original:
var nums = str.Select(c => (int)(c - '0'));
And here it is taking advantage of all cores:
var nums = str.AsParallel().Select(c => (int)(c - '0'));
pwned.
:)
Do you really need such high-falutin' tools for such a simple task?
Commodore-64's BASIC.
10 REM CONVERT STRING, S$, INTO ARRAY OF INTEGERS, A%
20 S$ = "02489"
30 L = LEN(S$)
40 DIM A%(L)
50 FOR X = 1 TO L
60 A%(X) = INT(MID$(S$, X, 1))
70 NEXT X
Untested and from memory.
(Stack Overflow's Syntax Highlighting doesn't have a C-64 BASIC mode? For shame!)
I'll bite...
Here it is in Scala:
digits.map(_.toInt)
And the concurrent form using Debasish's pmap implementation plus a little implicit conversion magic:
digits.pmap(_.toInt)
Smalltalk is still alive ;-)
'124890' asArray collect:[:c | c digitValue]
alternative:
'124890' asArray map:#digitValue
ToCharacterCode["01234"] - 48
(48 is the character code for "0")
This works because ToCharacterCode returns a list of the character codes for each character in the string and then subtracting a number from a list subtracts the number from each element of the list.
PowerShell:
"0123456789".ToCharArray() | %{$_-48}
As with other examples, 48 is the character code for '0'.
Type coercion is your friend.
Several ways to do it in FORTRAN. One of the easiest to understand is EQUIVALENCE.
INTEGER * 4 strTest(20) ! This is the string as an array of 4 byte integers
BYTE bTest(80) ! This is an array of bytes
EQUIVALENCE (strTest(1), bTest(1))
All character strings in FORTRAN may be represented as an array of values. The easiest ones to deal with are INTEGER*2, INTEGER*4 AND LOGICAL*1. Almost all of the FORTRAN compilers will deal with all of these. There are some exceptions for the LOGICAL. The code displayed is for a DEC machine. This code will work on everything from the PDP machines to the DEC Alpha. BYTE is a DEC specific data type. LOGICAL*1 will work on most machines, with the notable exception being IBM since it's not byte addressable.
Common Lisp (string holding the string of digit characters):
(map 'vector #'digit-char-p string)
ActionScript 3.0:
var string:String = "01234";
var array:Vector.<int> = new Vector.<int>()
var i:int = 0;
while (i < string.length)
{
array.push(string.slice(i, ++i));
}
Another one In c#
string str = "124890";
var res = str.ToCharArray().Select(x => Convert.ToInt32(((char)x).ToString())).ToArray();
Cheers
Ramesh Vel
IA32
Using the same assumptions about the input that DocMax made, the code can be reduced to:
mov esi,source
mov edi,dest
l1:
movzx eax,byte ptr [esi]
inc esi
sub al,'0'
jc done
stosd
jmp l1
done:
which is 17 bytes.
Skizz
C# & VB.net using linq...
var result = "123456789".ToCharArray().Select(
c => int.Parse(c.ToString())).ToArray();
or
Dim result = "123456789".ToCharArray().Select(
Function(c) Integer.Parse(c.ToString())).ToArray()