From: "shan (Shannon Skipper)" <noreply@...>
Date: 2022-05-03T19:52:01+00:00
Subject: [ruby-core:108468] [Ruby master Feature#18762] Add an Array#undigits that compliments Integer#digits

Issue #18762 has been updated by shan (Shannon Skipper).


sawa (Tsuyoshi Sawada) wrote in #note-5:
> @shan (Shannon Skipper)
> 
> Sorry. I had the code wrong. A similar code works for an array in backwards.
> 
> ```ruby
> [].inject(0){_1 * 10 + _2} # => 0
> [2, 1].inject(0){_1 * 10 + _2} # => 21
> [3, 2, 1].inject(0){_1 * 10 + _2} # => 321
> [6, 3, 2, 1].inject(0){_1 * 10 + _2} # => 6321
> ```

I think you'd just need to reverse it, since this result seems backwards. I think it's easy to get the implementation wrong and a handy method to have.
``` ruby
6321.digits.inject(0) { _1 * 10 + _2 } #=> 1234
6321.digits.reverse.inject(0) { _1 * 10 + _2 } #=> 4321
```

Using your #reduce strategy, you'd end up with something like the following.
``` ruby
class Array
  def undigits(base = 10)
    reverse.reduce(0) do |acc, digit|
      acc * base + digit
    end
  end
end
```
It's a fairly similar shape to what I had.
``` ruby
class Array
  def undigits(base = 10)
    each_with_index.sum do |digit, exponent|
      digit * base**exponent
    end
  end
end
```

I assumed we'd want to implement it in C if it's accepted, and was just trying to illustrate behavior, but unsure.

----------------------------------------
Feature #18762: Add an Array#undigits that compliments Integer#digits
https://bugs.ruby-lang.org/issues/18762#change-97507

* Author: shan (Shannon Skipper)
* Status: Open
* Priority: Normal
----------------------------------------
I've found Integer#digits convenient and useful but several times have needed to go from the place-value notation back to an Integer after manipulation and wished there was a complimentary Array#undigits.

``` ruby
class Array
  def undigits(base = 10)
    each_with_index.sum do |digit, exponent|
      digit * base**exponent
    end
  end
end

42.digits.undigits
#=> 42

42.digits(16).undigits(16)
#=> 42
```

Below is my stab at a Ruby implementation with behavior mirroring Integer#digits.
``` ruby
class Array
  def undigits(base = 10)
    base_int = base.to_int
    raise TypeError, "wrong argument type #{base_int.class} (expected Integer)" unless base_int.is_a?(Integer)
    raise ArgumentError, 'negative radix' if base_int.negative?
    raise ArgumentError, "invalid radix #{base_int}" if base_int < 2

    each_with_index.sum do |digit, exponent|
      raise MathDomainError, 'out of domain' if digit.negative?

      digit * base_int**exponent
    end
  end
end
```




-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>