The code is used to add the digits in a digital clock to each other. I duplicated code and could use some help DRYing it out
For your current code:


Don't name variables float and number; name then for what they represent, not their datatype.
Don't use camelCase for methods; Ruby convention is to use snake_case


As for its functionality: There's a much easier way to get hours and minutes from a total number of minutes:

hours, minutes = total.divmod(60)


#divmod is basically a convenient shorthand for "quotient and remainder"; it's the same as this:

hours = (total / 60).floor
minutes = total % 60


just in one method.

Now, #divmod returns an array with 2 numbers in it, and in the code above I simply assign those two numbers to hours and minutes respectively. 

If you then use #divmod again on those two but with 10 as the argument, you can get the "ones" and the "tens", the same way you just got "minutes" and "hours" by using 60 as your argument.

So say the total number of minutes is 119, i.e. 1h 59m, and you want to split both the hours and minutes, you can do this:

total
  .divmod(60)                    #=&gt; [1, 59]
  .flat_map { |n| n.divmod(10) } #=&gt; [0, 1, 5, 9]


Note however, that if you've got more than 99 hours, you could run into problems, as you'll only get the ones and tens; not the hundreds. E.g. 6000 minutes is 100 hours, but the above would return [10, 0, 0, 0] (sum 10), rather than all the individual digits, which would be [1, 0, 0, 0, 0] (sum 1).

This might be correct for the challenge still, since the readout is hh:mm, and thus doesn't say anything one way or the other about how 3-or-more hour-digits should be handled. The "digital sum" might be 10 or 1 - or zero if anything above 4 digits is just ignored. Or it could be d:hh:mm, and it'd be 4 days + 4 hours + 0 minutes = 8... there are just a lot of unknowns.

But if we assume that the input will stick to 2-digit hours, the code above will work without any ambiguity - all we need is the sum. For that you can use #reduce (aka #inject):

def late_ride(minutes)
  minutes
    .divmod(60)
    .flat_map { |n| n.divmod(10) }
    .reduce(:+)
end


and bingo.

But if the idea instead is to add up all the digits individually and the hours can have 3 or more digits, this, as mentioned, won't be quite right. 

You can use #divmod repeatedly or recursively to get the digits of an arbitrary number of hours, but for this little challenge, I'll just suggest something I usually don't suggest: Convert the digital readout to a string, and get the digits that way. I usually try to avoid this, since it seems inelegant to treat a numeric value as a string only to get another numeric value. Just hey, it works, so:

total
  .divmod(60)  #=&gt; [1, 59]
  .join        #=&gt; "159"
  .chars       #=&gt; ["1", "5", "9"]


From here, you can use #reduce again to get the sum (just call to_i to get actual numbers from the strings). And then this is your method:

def late_ride(minutes)
  minutes
    .divmod(60)
    .join
    .chars
    .reduce(0) { |sum, n| sum + n.to_i }
end


or, written another way:

def late_ride(minutes)
  minutes
    .divmod(60)
    .join
    .chars
    .map(&amp;:to_i)
    .reduce(:+)
end