```On Thu, May 30, 2013 at 6:59 PM, Alphonse 23 <lists / ruby-forum.com> wrote:
> Which way is the eloquent ruby way to write this algorithm?
>
> Kaprekar Number
>
> 9 is a Kaprekar number since
> 9 ^ 2 = 81 and 8 + 1 = 9
>
> 297 is also Kaprekar number since
> 297 ^ 2 = 88209 and 88 + 209 = 297.
>
> In short, for a Kaprekar number k with n-digits, if you square it and
> add the right n digits to the left n or n-1 digits, the resultant sum is
> k.
>
> !Spoiler Below!
>
> # way one
> def kaprekar?(k)
>   ks = k**2
>   lenf = (ks.to_s.length)-1
>   lenh = (ks.to_s.length / 2) - 1
>   a = ks.to_s[0..lenh].to_i
>   b = ks.to_s[lenh+1..lenf].to_i
>   k == (a+b)
> end
>
> # way two
> def kaprekar?(k)
>   a = (k**2).to_s[0..((((k**2).to_s.length) / 2) - 1)].to_i
>   b = (k**2).to_s[(((((k**2).to_s.length) / 2) -
> 1)+1)..(((k**2).to_s.length)-1)].to_i
>   k == (a+b)
> end
>
> # way three
> def kaprekar?(k)
>   k == ((k**2).to_s[0..((((k**2).to_s.length) / 2) -
> 1)].to_i)+((k**2).to_s[(((((k**2).to_s.length) / 2) -
> 1)+1)..(((k**2).to_s.length)-1)].to_i)
> end
>
> def  simple_test(i)
>   if kaprekar?(i) == true then p "success on #{i}" else "fail on #{i}"
> end
> end
>
> simple_test(9)
> simple_test(297)
>
> All three pass my tests, but which of the three would be considered the
> most eloquent written ruby way? As in, which would be consider best
> style-wise? The first takes up the most lines, but uses less nesting.
> The last uses only one line but uses lots of nesting.
>
> --
> Posted via http://www.ruby-forum.com/.
>

This is the way I'd do it:

def kaprekar?(k)

n = k.to_s.length
ks = (k*k).to_s
l = ((n-1)-(n%2))
l = 0 if l < 0

nl = ks[0..l].to_i
nr = ks[-n..-1].to_i

k == nl + nr

end

I could not say if that's more rubyist or not, though. I imagine there
is probably a way to use map/reduce and pass a block or something ;)

```