Digital root/Multiplicative digital root: Difference between revisions

</pre>

Show all output on this page.

 

 

=={{header|11l}}==

{{trans|Python}}

V count = 0

V mdr = n

L(val) table

print(‘#2: ’.format(L.index), end' ‘’)

 

{{out}}

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}}

 

=={{header|ALGOL 68}}==

# structure to hold the results of calculating the digital root & persistence #

MODE DR = STRUCT( INT root, INT persistence );

print md root( 899998 );

tabulate mdr( 5 )

{{out}}

<pre>

 

=={{header|ALGOL W}}==

% calculate the Multiplicative Digital Root (mdr) and Multiplicative Persistence (mp) of n %

procedure getMDR ( integer value n

end

 

{{out}}

<pre>

 

=={{header|AWK}}==

 

BEGIN {

} # for pos

 

{{out}}

<pre>

 

=={{header|Bracmat}}==

& ( MP/MDR

= prod L n

& put$\n

)

{{out}}

<pre>123321 : (3.8)

 

=={{header|C}}==

#include <stdio.h>

 

return 0;

}

{{out}}

<pre>

 

=={{header|C sharp|C#}}==

using System.Collections.Generic;

using System.Linq;

Console.WriteLine(" {0} : [{1}]", i, string.Join(", ", table[i]));

}

{{out}}

<pre>123321 has multiplicative persistence 3 and multiplicative digital root 8

 

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

#include <iomanip>

#include <map>

return system( "pause" );

}

{{out}}

<pre>

 

=={{header|CLU}}==

while n>0 do

yield(n//10)

stream$putl(po, "")

end

{{out}}

<pre> N MDR MP

 

=={{header|Common Lisp}}==

(defun mdr/p (n)

"Return a list with MDR and MP of n"

do (format t "~6@a: ~{~3@a ~}~%" el (mdr/p el)))

(format t "~%MDR: [n0..n4]~%")

{{out}}

<pre>

=={{header|Component Pascal}}==

{{Works with| BlackBox Component Builder}}

MODULE MDR;

IMPORT StdLog, Strings, TextMappers, DevCommanders;

 

END MDR.

Execute:

^Q MDR.Do 123321 7739 893 899998 ~

=={{header|D}}==

{{trans|Python}}

 

/// Multiplicative digital root.

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 {

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

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

 

===More Efficient Version===

 

/// Multiplicative digital root.

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

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

The output is similar.

 

=={{header|Elixir}}==

def mdroot(n), do: mdroot(n, 0)

 

Digital.task1([123321, 7739, 893, 899998])

 

{{out}}

 

=={{header|F_Sharp|F#}}==

// mdr. Nigel Galloway: June 29th., 2021

let rec fG n g=if n=0 then g else fG(n/10)(g*(n%10))

let fN g=Seq.initInfinite id|>Seq.filter((mdr>>fst>>(=)g))|>Seq.take 5

seq{0..9}|>Seq.iter(fun n->printf "First 5 numbers with mdr %d -> " n; Seq.initInfinite id|>Seq.filter((mdr>>fst>>(=)n))|>Seq.take 5|>Seq.iter(printf "%d ");printfn "")

{{out}}

<pre>

</pre>

=={{header|Factor}}==

math.text.utils prettyprint sequences ;

IN: rosetta-code.multiplicative-digital-root

{ 123321 7739 893 899998 } [ print-mdr ] each nl first5-table ;

 

{{out}}

<pre>

 

=={{header|Fortran}}==

!Implemented by Anant Dixit (Oct, 2014)

program mdr

end subroutine

 

 

<pre>

 

=={{header|FreeBASIC}}==

 

Function multDigitalRoot(n As UInteger, ByRef mp As Integer, base_ As Integer = 10) As Integer

Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|Go}}==

 

import "fmt"

fmt.Printf(tableFmt, i, l)

}

{{out}}

<pre>

=={{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

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

 

{{out}}

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

 

=={{header|jq}}==

def u: if condition then . else (next|u) end;

u;

end;

 

def neatly:

. as $in

"Tabulation",

"MDR: [n0..n4]",

{{out}}

 

i : [MDR, MP]

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

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

 

=={{header|Julia}}==

'''Function'''

function digitalmultroot{S<:Integer,T<:Integer}(n::S, bs::T=10)

-1 < n && 1 < bs || throw(DomainError())

return (pers, ds)

end

'''Main'''

const bs = 10

const excnt = 5

println(join([@sprintf("%6d", dmr[i, j]) for j in 1:excnt], ","))

end

 

{{out}}

=={{header|Kotlin}}==

{{trans|FreeBASIC}}

 

fun multDigitalRoot(n: Int): Pair<Int, Int> = when {

println()

}

 

{{out}}

9: 9 19 33 91 119

</pre>

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

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]

 

{{out}}

=={{header|Nim}}==

{{trans|Python}}

proc mdroot(n: int): tuple[mp, mdr: int] =

for mp, val in table:

 

{{out}}

 

=={{header|PARI/GP}}==

apply(a, [123321, 7739, 893, 899998])

{{out}}

<pre>%1 = [[3, 8], [3, 8], [3, 2], [2, 0]]

inspired by [[Worthwhile_task_shaving]] :-)<BR>

Brute force speed up GetMulDigits.

{$IFDEF FPC}

{$MODE DELPHI}{$OPTIMIZATION ON,ALL}{$CODEALIGN proc=16}

readln;

{$ENDIF}

{{out|@TIO.RUN}}

<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)

 

=={{header|PicoLisp}}==

"Returns the solutions in a list, i.e., '(MDR MP)"

(let MP 0

(tab Fmt "===" " " "======")

(for (I . S) *Solutions

 

{{out}}

 

=={{header|Phix}}==

{{out}}

<pre>

8 8 18 24 29 36

9 9 19 33 91 119

</pre>

 

===version 1===

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

 

declare n fixed binary (31);

end;

 

{{out}}

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

 

===version 2===

Dcl (x,p,r) Bin Fixed(31);

Put Edit('number persistence multiplicative digital root')(Skip,a);

End;

End;

{{out}}

<pre>number persistence multiplicative digital root

=={{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}}

=={{header|Quackery}}==

 

[ base share /mod

rot * swap

' [ 123321 7739 893 899998 ] witheach task.1

cr

 

{{out}}

 

=={{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

=={{header|Raku}}==

(formerly Perl 6)

return .elems - 1, .[.end]

given cache($n, {[*] .comb} ... *.chars == 1)

say "$d : ", .[^5]

given (1..*).grep: *.&multiplicative-digital-root[1] == $d;

{{out}}

<pre>123321: 3 8

8 : 8 18 24 29 36

9 : 9 19 33 91 119</pre>

 

=={{header|REXX}}==

===idomatic version===

numeric digits 100 /*increase the number of decimal digits*/

parse arg x /*obtain optional arguments from the CL*/

y=r

end /*p*/ /* [↑] wash, rinse, and repeat ··· */

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

===ultra-fast version===

This fast version can handle a target of five hundred numbers with ease for the 2^nd part of the task's requirement.

numeric digits 2000 /*increase the number of decimal digits*/

parse arg target x /*obtain optional arguments from the CL*/

end /*p*/ /* [↑] wash, rinse, and repeat ··· */

if s==1 then return r /*return multiplicative digital root. */

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 34 </tt>}}

<pre>

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|Ring}}==

# Project : Digital root/Multiplicative digital root

 

end

next

Output:

<pre>

8 => 8 18 24 29 36

9 => 9 19 33 91 119

</pre>

 

=={{header|Ruby}}==

{{works with|Ruby|2.4}}

mdr, persist = n, 0

until mdr < 10 do

end

puts "", "MDR: [n0..n4]", "=== ========"

{{out}}

<pre>

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

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

</pre>

 

{{works with|Scala|2.9.x}}

 

 

object MDR extends App {

.foreach{p => printf("%3s: [%s]\n",p._2,p._1.mkString(", "))}

 

 

{{out}}

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

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

 

=={{header|Sidef}}==

{{trans|Ruby}}

var (mdr, persist) = (n, 0)

while (mdr >= 10) {

 

say "\nMDR: [n0..n4]\n=== ========"

 

{{out}}

 

=={{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>

 

{{libheader|Wren-fmt}}

The size of some of the numbers here is such that we need to use BigInt.

 

// Only valid for n > 0 && base >= 2

Fmt.print("$3d: $s", i, l.toString)

i = i + 1

 

{{out}}

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>