Permuted multiples: Difference between revisions

 

=={{header|APL}}==

{{out}}

<pre>142857 285714 428571 571428 714285 857142</pre>

Shifting the 26 up against the 1 obviously keeps the "at least" condition satisfied for longer during the subsequent additions of 3 at the low end and gives a start point much closer to the next power. This more than halves the number of steps performed and thus the time taken. It also produces the correct result(s), but I can't see that it's logically bound to do so. :\

 

use sorter : script "Insertion Sort" -- <https://www.rosettacode.org/wiki/Sorting_algorithms/Insertion_sort#AppleScript>

 

end task

 

 

{{output}}

Using 'set n to n10 + 26':

Nothing below 10000 (228 steps)

Nothing below 100000 (2442 steps)

4 * n = 571428

5 * n = 714285

{{output}}

Using 'set n to n10 * 1.26 as integer':

Nothing below 10000 (150 steps)

Nothing below 100000 (1506 steps)

5 * n = 714285

6 * n = 857142"

 

=={{header|C}}==

#include <stdbool.h>

 

printf("%d * n = %d\n", mult, n*mult);

return 0;

{{out}}

<pre>1 * n = 142857

 

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

#include <iostream>

 

}

}

 

{{out}}

 

=={{header|CLU}}==

digits = iter (n: int) yields (int)

while n>0 do

stream$putl(po, int$unparse(mult) || " * n = " || int$unparse(mult*n))

end

{{out}}

<pre>1 * n = 142857

 

=={{header|Cowgol}}==

 

# Return the amount of times each digit appears in a number

print_nl();

i := i+1;

{{out}}

<pre>1 * n = 142857

 

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

// Permuted multiples. Nigel Galloway: August 18th., 2021

let fG n g=let rec fN g=[if g>0 then yield g%10; yield! fN(g/10)] in List.sort(fN n)=List.sort(fN g)

let n=Seq.initInfinite((+)2)|>Seq.collect(fun n->seq{(pown 10 n)+2..3..(pown 10 (n+1))/6})|>Seq.find(fun g->let fN=fG g in fN(g*2)&&fN(g*3)&&fN(g*4)&&fN(g*5)&&fN(g*6))

printfn $"The solution to Project Euler 52 is %d{n}"

{{out}}

<pre>

{{libheader|Factor-numspec}}

{{works with|Factor|0.99 2021-06-02}}

math.vectors numspec present prettyprint sequences sets ;

 

 

{ 2 3 4 5 6 } " n: " write smallest-permuted-multiple dup .

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

'quick and dirty bubblesort, not the focus of this exercise

dim as string t = s

print n, 2*n, 3*n, 4*n, 5*n, 6*n

end

{{out}}<pre>

142857 285714 428571 571428 714285 857142

{{trans|Wren}}

{{libheader|Go-rcu}}

 

import (

i = i + 1

}

 

{{out}}

 

=={{header|Java}}==

 

public class PermutedMultiples {

return digits;

}

 

{{out}}

 

The following uses a simple generate-and-test approach but with early backtracking, so it's quite reasonable.

 

first(range(1; infinite)

| . as $i

| (digits|sort) as $reference

{{out}}

<pre>

 

=={{header|Julia}}==

println("n: $n, 2n: $(2n), 3n: $(3n), 4n: $(4n), 5n: $(5n), 6n: $(6n)")

<pre>

n: 142857, 2n: 285714, 3n: 428571, 4n: 571428, 5n: 714285, 6n: 857142

 

=={{header|MAD}}==

VECTOR VALUES TENMUL = 1,10,100,1000,10000,100000,

1 1000000,10000000,100000000,1000000000

THROUGH SHOW, FOR M=1, 1, M.G.6

SHOW PRINT FORMAT FMT, M, N*M

{{out}}

<pre>1 * N = 142857

Searching among multiples of 3 between 102 and 1_000 div 6, 1_002 and 10_000 div 6, 10_002 and 100_000 div 6, etc. (see discussion).

 

 

func search(): int =

echo " n = ", n

for k in 2..6:

 

{{out}}

Using set of tdigit ,so no sort of digits is required.<BR>

Don't use the fact, that second digit must be < 6.Runtime negligible.<BR>

{$IFDEF FPC}

{$MOde DElphi} {$Optimization On,ALL}

readln;

{$ENDIF}

{{out}}

<pre>TIO.RUN

 

=={{header|Perl}}==

 

use strict; # https://rosettacode.org/wiki/Permuted_multiples

};

printf " n %s\n", $n;

{{out}}

<pre>

=={{header|Phix}}==

Maintain a limit (n10) and bump the iteration whenever *6 increases the number of digits, which (as [was] shown) cuts the number of iterations by a factor of nearly thirteen and a half times (as in eg [as was] 67 iterations instead of 900 to find nothing in 100..1,000). Also as noted on the talk page, since sum(digits(3n)) is a multiple of 3 and it uses the same digits as n, then sum(digits(n)) will also be the very same multiple of 3 and hence n must (also) be divisible by 3, so we can start each longer-digits iteration on 10^k+2 (since remainder(10^k,3) is always 1) and employ a step of 3, and enjoy a better than 40-fold overall reduction in iterations.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

 

=={{header|Raku}}==

 

{{out}}

<pre> n: 142857

 

=={{header|REXX}}==

/*───────────────────────── 2*n, 3*n, 4*5, 5*6, and 6*n contain the same decimal digits.*/

do n=1 /*increment N from unity 'til answer.*/

exit 0 /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

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

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

 

 

see "done..." + nl

{{out}}

<pre>

 

=={{header|Swift}}==

var n = num

var digits = Array(repeating: 0, count: 10)

}

p *= 10

 

{{out}}

{{libheader|Wren-math}}

One thing that's immediately clear is that the number must begin with '1' otherwise the higher multiples will have more digits than it has.

 

// assumes l1 is sorted but l2 is not

}

i = i + 1

 

{{out}}

 

=={{header|XPL0}}==

int N, Sums;

[Sums:= 0;

];

IntOut(0, N);

 

{{out}}