[xclite]

I imagine this one will be trivial for most of you, but it will still be fun to do. I'm pulling this one from a problem in Project Euler because the same idea is used in a few problems.

The challenge is to sum the digits of an integer-style number in the fewest characters possible. Your function should take a number(assuming it is a string or an int class is allowed, just assume the argument is of the type you need) and return the sum.

For those of you who know about passing methods/procs/blocks, try allowing the function to perform any accumulative algorithm across the digits - i.e. any algorithm that keeps a running value and uses the next value to alter it. Examples would be multiplying all the digits or raising each digit to a power and then raising that value to the next digit's power and so on.

This post has been edited by xclite: 16 March 2011 - 06:19 AM

[T3hC13h]

Two entries, one with strings, one with numbas.

Spoiler

s = 0
v.to_s.chars{|c| s+=c.to_i}

Spoiler

s = 0
while v > 0 do
    v,r = v.divmod(10)
    s+=r
end

This post has been edited by T3hC13h: 16 March 2011 - 12:12 PM

[ishkabible]

this is in C++, ill post some ruby later

Spoiler

while(*p)i+=*p-48;

this assumes that p is a null terminated string and i was declared as some type of number value

[Karel-Lodewijk]

A different approach, slightly shorter

eval v.gsub /./,'+\0'

See what I did there, I add plus signs in between the characters of the string and then ask ruby to evaluate it as ruby code.


and the shortest recursive solution I can think of, because recursion is fun:

f=lambda{|x|x==""?0:f.(x[1..-1])+x[0].to_i}
f.(v)

still sort of bothers me that I can't think of everything shorter than the c example

This post has been edited by Karel-Lodewijk: 17 March 2011 - 05:53 PM

[5thWall]

Two solutions from me. One using numbers and recursion and the other using strings and no recursion. Not as short as some of the others, but I managed to do both on one line each, no ';' required.

Spoiler

#with recursion
(f=lambda{|x|x<10?x:f.(x/10)+x%10}).(v)

#longer, but I wanted to see if I could use divmod and still be on one line
(f=lambda{|x|x<10?x:f.((y=x.divmod 10)[0])+y[1]}).(v)

Spoiler

#with strings
v.chars.inject(0){|m,o|m+o.to_i}