Digital root/Multiplicative digital root: Difference between revisions

{{task|Mathematics}}

The [[wp:Multiplicative digital root|multiplicative digital root]] (MDR) and multiplicative persistence (MP) of a number, <math>n</math>, is calculated rather like the [[Digital root]] except digits are multiplied instead of being added:

# Set <math>m</math> to <math>n</math> and <math>i</math> to <math>0</math>.

#* Increment <math>i</math>.

# Return <math>i</math> (= MP) and <math>m</math> (= MDR)

 

;Task:

* Tabulate the MP and MDR of the numbers 123321, 7739, 893, 899998

* Tabulate MDR versus the first five numbers having that MDR, something like:

=== ========

0: [0, 10, 20, 25, 30]

7: [7, 17, 71, 117, 171]

8: [8, 18, 24, 29, 36]

Show all output on this page.

 

;References:

* [http://mathworld.wolfram.com/MultiplicativeDigitalRoot.html Multiplicative Digital Root] on Wolfram Mathworld.

* [http://oeis.org/A031347 Multiplicative digital root] on The On-Line Encyclopedia of Integer Sequences.

 

=={{header|Ada}}==

The solution uses the Package "Generic_Root" from the additive digital roots [[http://rosettacode.org/wiki/Digital_root#Ada]].

 

 

procedure Multiplicative_Root is

TIO.New_Line;

end loop;

 

{{out}}

8 8, 18, 24, 29, 36

9 9, 19, 33, 91, 119

</pre>

 

=={{header|Bracmat}}==

& ( MP/MDR

= prod L n

& put$\n

)

<pre>123321 : (3.8)

7739 : (3.8)

8 :8 18 24 29 36

9 :9 19 33 91 119</pre>

 

=={{header|C++}}==

#include <iomanip>

#include <map>

return system( "pause" );

}

{{out}}

<pre>

| 9| 9 19 33 91 119 |

+-------+------------------------------------+

</pre>

 

=={{header|D}}==

{{trans|Python}}

 

/// Multiplicative digital root.

writefln("%6d: (%s, %s)", n, n.mdRoot[]);

 

auto n = 0;

while (table.byValue.map!walkLength.reduce!min < 5) {

foreach (const mp; table.byKey.array.sort())

writefln("%2d: %s", mp, table[mp].take(5));

{{out}}

<pre>Number: (MP, MDR)

 

===Alternative Version===

 

uint digitsProduct(uint n) pure nothrow @nogc {

writefln("%6d: (%s, %s)", n, n.mdRoot[]);

 

auto n = 0;

while (table.byValue.map!walkLength.reduce!min < 5) {

foreach (const mp; table.byKey.array.sort())

writefln("%2d: %s", mp, table[mp].take(5));

 

===More Efficient Version===

 

/// Multiplicative digital root.

writefln("%6d: %s", n, n.mdRoot);

 

auto n = 0;

while (table.byValue.map!walkLength.reduce!min < 5) {

foreach (const mp; table.byKey.array.sort())

writefln("%2d: %s", mp, table[mp].take(5));

The output is similar.

 

=={{header|Haskell}}==

Note that in the function <code>mdrNums</code> we don't know in advance how many numbers we'll need to examine to find the first 5 associated with all the MDRs. Using a lazy array to accumulate these numbers allows us to keep the function simple.

import Data.Array

import Data.LazyArray

digits 0 = [0]

digits n = unfoldr step n

 

printMpMdrs :: [Integer] -> IO ()

printMpMdrs [123321, 7739, 893, 899998]

putStrLn ""

{{out}}

Note that the values in the first column of the table are MDRs, as shown in the task's sample output, not MP as incorrectly stated in the task statement and column header.

 

Works in both languages:

write(right("n",8)," ",right("MP",8),right("MDR",5))

every r := mdr(n := 123321|7739|893|899998) do

while m > 0 do c *:= 1(m%10, m/:=10)

return c

 

<pre>

->drmdr

First, we need something to split a number into digits:

 

 

Second, we need to find their product:

 

 

Then we use this inductively until it converges:

 

 

MP is one less than the length of this list, and MDR is the last element of this list:

 

3 8

(<:@#,{:) */@(10&#.inv)^:a: 7739

3 2

(<:@#,{:) */@(10&#.inv)^:a: 899998

 

For the table, we don't need that whole list, we only need the final value. Then use these values to classify the original argument (taking the first five from each group):

 

0 10 20 25 30

1 11 111 1111 11111

7 17 71 117 171

8 18 24 29 36

 

Note that since the first 10 non-negative integers are single digit values, the first column here doubles as a label (representing the corresponding multiplicative digital root).

=={{header|Java}}==

{{works with|Java|8}}

 

public class MultiplicativeDigitalRoot {

return new long[]{n, mdr, mp};

}

 

<pre>NUMBER MDR MP

9: 9 19 33 91 119 </pre>

 

ClearAll[mdr, mp, nums];

mdr[n_] := NestWhile[Times @@ IntegerDigits[#] &, n, # > 9 &];

TableForm[Table[{i, Take[nums[[i + 1]], 5]}, {i, 0, 9}],

TableHeadings -> {None, {"MDR", "First 5"}}, TableDepth -> 2]

 

<pre>

Number MDR MP

</pre>

 

{{trans|Python}}

var mdr = @[n]

while mdr[mdr.high] > 9:

mdr.add n

(mdr.high, mdr[mdr.high])

for n in [123321, 7739, 893, 899998]:

echo align($n, 6)," ",mdroot(n)

echo ""

var table = newSeqWith(10, newSeq[int]())

for n in 0..int.high:

if table.map((x: seq[int]) => x.len).min >= 5: break

table[mdroot(n).mdr].add n

for mp, val in table:

<pre>123321 (mp: 3, mdr: 8)

7739 (mp: 3, mdr: 8)

8: @[8, 18, 24, 29, 36]

9: @[9, 19, 33, 91, 119]</pre>

 

=={{header|Perl}}==

{{trans|D}}

use strict;

 

my @n = map { $i++ while (mdr($i))[1] != $target; $i++; } 1..5;

print " $target: [", join(", ", @n), "]\n";

{{out}}

<pre>Number: (MP, MDR)

9: [9, 19, 33, 91, 119]</pre>

 

 

 

{{out}}

 

=={{header|PL/I}}==

{{incomplete|PL/I|Missing second half of task!}}

 

declare n fixed binary (31);

end;

 

<pre>N= 123321 MDR= 8 MP= 3;

N= 7739 MDR= 8 MP= 3;

N= 893 MDR= 2 MP= 3;

N= 899998 MDR= 0 MP= 2;</pre>

 

=={{header|Python}}==

===Python: Inspired by the solution to the [[Digital root#Python|Digital root]] task===

from functools import reduce

except:

print('\nMP: [n0..n4]\n== ========')

for mp, val in sorted(table.items()):

 

{{out}}

===Python: Inspired by the [[Digital_root/Multiplicative_digital_root#More_Efficient_Version|more efficient version of D]].===

Substitute the following function to run twice as fast when calculating mdroot(n) with n in range(1000000).

count, mdr = 0, n

while mdr > 9:

mdr = digitsMul

count += 1

 

{{out}}

(Exactly the same as before).

 

=={{header|Racket}}==

(define (digital-product n)

(define (inr-d-p m rv)

(for ((MDR (in-range 10)))

(define (has-mdr? n) (define-values (mdr mp) (mdr/mp n)) (= mdr MDR))

{{out}}

<pre>Number MDR mp

8 (8 18 24 29 36)

9 (9 19 33 91 119)</pre>

 

=={{header|REXX}}==

===idomatic version===

say 'MDR first ' target " numbers that have a matching MDR"

say '═══ ═══════════════════════════════════════════════════'

<pre>

number persistence multiplicative digital root

893 3 2

899998 2 0

 

MDR first 5 numbers that have a matching MDR

8: [8, 18, 24, 29, 36]

9: [9, 19, 33, 91, 119]

</pre>

 

===ultra-fast version===

say center('number',8) ' persistence multiplicative digital root'

say copies('─' ,8) ' ─────────── ───────────────────────────'

say 'MDR first ' target " numbers that have a matching MDR"

 

 

 

 

 

<pre>

number persistence multiplicative digital root

893 3 2

899998 2 0

 

MDR first 34 numbers that have a matching MDR

8: [8 18 24 29 36 38 42 46 49 63 64 66 67 76 77 79 81 83 88 92 94 97 99 118 124 129 136 138 142 146 149 163 164 166]

9: [9 19 33 91 119 133 191 313 331 911 1119 1133 1191 1313 1331 1911 3113 3131 3311 9111 11119 11133 11191 11313 11331 11911 13113 13131 13311 19111 31113 31131 31311 33111]

</pre>

 

=={{header|Ruby}}==

persist += 1

end

end

 

counter = Hash.new{|h,k| h[k]=[]}

0.step do |i|

break if counter.values.all?{|v| v.size >= 5 }

end

{{out}}

<pre>

 

=={{header|Tcl}}==

if {$n < 0 || ![string is integer $n]} {

error "must be an integer"

}

return [list $i $n]

Demonstrating:

puts [regsub -all . "Number: MP MDR" -]

foreach n {123321 7739 893 899998} {

for {set i 0} {$i < 10} {incr i} {

puts [format "%3d: (%s)" $i [join [lrange $accum($i) 0 4] ", "]]

{{out}}

<pre>

8: (8, 18, 24, 29, 36)

9: (9, 19, 33, 91, 119)

</pre>

 

=={{header|zkl}}==

{{trans|Python}}

mdr := List(n);

while (mdr[-1] > 9){

}

return(mdr.len() - 1, mdr[-1]);

count:=0; mdr:=n;

while(mdr > 9){

}

return(count, mdr);

foreach n in (T(123321, 7739, 893, 899998))

{ println("%7,d: %s".fmt(n, mdroot(n))) }

foreach mp in (table.keys.sort()){

println("%2d: %s".fmt(mp, table[mp][0,5])); //print first five values

{{out}}

<pre>