Zumkeller numbers: Difference between revisions
Content deleted Content added
J draft |
lang tag update Tag: Reverted |
||
Line 37:
{{trans|D}}
<
V divs = [1, n]
V i = 2
Line 145:
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program zumkellex641.s */
Line 661:
On my machine, this takes about 0.28 seconds to perform the two main searches and a further 107 to do the stretch task. However, the latter time can be dramatically reduced to 1.7 seconds with the cheat of knowing beforehand that the first 200 or so odd Zumkellers not ending with 5 are divisible by 63. The "abundant number" optimisation's now used with odd numbers, but the cheat-free running time was only two to three seconds longer without it.
<
on aliquotSum(n)
if (n < 2) then return 0
Line 822:
{{output}}
<
6 12 20 24 28 30 40 42 48 54 56 60 66 70 78 80 84 88 90 96
102 104 108 112 114 120 126 132 138 140 150 156 160 168 174 176 180 186 192 198
Line 849:
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<
/* ARM assembly Raspberry PI */
/* program zumkeller4.s */
Line 1,560:
=={{header|C sharp|C#}}==
{{trans|Go}}
<
using System.Collections.Generic;
using System.Linq;
Line 1,684:
=={{header|C++}}==
<
#include <cmath>
#include <vector>
Line 1,871:
=={{header|D}}==
{{trans|C#}}
<
import std.stdio;
Line 1,991:
=={{header|F_Sharp|F#}}==
This task uses [https://rosettacode.org/wiki/Sum_of_divisors#F.23]
<
// Zumkeller numbers: Nigel Galloway. May 16th., 2021
let rec fG n g=match g with h::_ when h>=n->h=n |h::t->fG n t || fG(n-h) t |_->false
Line 2,013:
=={{header|Factor}}==
{{works with|Factor|0.99 2019-10-06}}
<
math.primes.factors memoize prettyprint sequences ;
Line 2,085:
=={{header|Go}}==
<
import "fmt"
Line 2,208:
=={{header|Haskell}}==
{{Trans|Python}}
<
import Data.List.Split (chunksOf)
import Data.Numbers.Primes (primeFactors)
Line 2,313:
=={{header|J}}==
Implementation:<
zum=: {{
if. 2|s=. +/divs=. divisors y do. 0
Line 2,321:
}}@></lang>
Task examples:<
6 12 20 24 28 30 40 42 48 54 56 60 66 70 78 80 84 88 90 96 102 104
108 112 114 120 126 132 138 140 150 156 160 168 174 176 180 186 192 198 204 208 210 216
Line 2,343:
1095633 1108107 1145529 1162161 1198197 1224531 1270269 1307691 1324323 1378377</lang>
=={{header|Java}}==
<
import java.util.ArrayList;
import java.util.Collections;
Line 2,497:
generates a stream of partitions is easily transformed into a
specialized function that prunes irrelevant partitions efficiently.
<
def factors:
. as $num
Line 2,563:
end
| true)
// false;</lang><
"First 220:", limit(220; range(2; infinite) | select(is_zumkeller)),
Line 2,589:
=={{header|Julia}}==
<
function factorize(n)
Line 2,671:
=={{header|Kotlin}}==
{{trans|Java}}
<
import kotlin.math.sqrt
Line 2,807:
=={{header|Lobster}}==
<
// Derived from Julia and Python versions
Line 2,903:
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
ZumkellerQ[n_] := Module[{d = Divisors[n], t, ds, x},
ds = Total[d];
Line 2,936:
=={{header|Nim}}==
{{trans|Go}}
<
template isEven(n: int): bool = (n and 1) == 0
Line 3,038:
Now using the trick, that one partition sum must include n and improved recursive search.<BR>
Limit is ~1.2e11
<
//https://oeis.org/A083206/a083206.txt
{$IFDEF FPC}
Line 3,809:
=={{header|Perl}}==
{{libheader|ntheory}}
<
use warnings;
use feature 'say';
Line 3,883:
=={{header|Phix}}==
{{trans|Go}}
<!--<
<span style="color: #008080;">function</span> <span style="color: #000000;">isPartSum</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">l</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">t</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">t</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #004600;">true</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
Line 3,964:
=={{header|PicoLisp}}==
<
(make
(for I N
Line 4,046:
===Procedural===
Modified from a footnote at OEIS A083207 (see reference in problem text) by Charles R Greathouse IV.
<
from sympy.combinatorics.subsets import Subset
Line 4,116:
Relying on the standard Python libraries, as an alternative to importing SymPy:
<
from itertools import (
Line 4,355:
{{trans|Zkl}}
<
(require math/number-theory)
Line 4,419:
(formerly Perl 6)
{{libheader|ntheory}}
<
sub zumkeller ($range) {
Line 4,478:
=={{header|REXX}}==
The construction of the partitions were created in the order in which the most likely partitions would match.
<
parse arg n m v . /*obtain optional arguments from the CL*/
if n=='' | n=="," then n= 220 /*Not specified? Then use the default.*/
Line 4,591:
=={{header|Ring}}==
<
load "stdlib.ring"
Line 4,782:
=={{header|Ruby}}==
<
def divisors
Line 4,852:
=={{header|Rust}}==
<
use std::convert::TryInto;
Line 4,955:
=={{header|Sidef}}==
<
return false if n.is_prime
Line 5,002:
=={{header|Standard ML}}==
<
exception Found of string ;
Line 5,057:
</lang>
call loop and output - interpreter
<
- val Zumkellerlist = fn step => fn no5 =>
let
Line 5,096:
{{trans|Go}}
<
extension BinaryInteger {
Line 5,166:
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<
Function GetDivisors(n As Integer) As List(Of Integer)
Dim divs As New List(Of Integer) From {
Line 5,295:
=={{header|Vlang}}==
{{trans|Go}}
<
mut divs := [1, n]
for i := 2; i*i <= n; i++ {
Line 5,418:
{{libheader|Wren-fmt}}
I've reversed the order of the recursive calls in the last line of the ''isPartSum'' function which, as noted in the Phix entry, seems to make little difference to Go but (as one might have expected) speeds up this Wren script enormously. The first part is now near instant but was taking several minutes previously. Overall it's now only about 5.5 times slower than Go itself which is a good result for the Wren interpreter.
<
import "/fmt" for Fmt
import "io" for Stdout
Line 5,517:
=={{header|zkl}}==
{{trans|Julia}} {{trans|Go}}
<
// if(n==1) return(T); // we con't care about this case
( pd:=[1..(n).toFloat().sqrt()].filter('wrap(x){ n%x==0 }) )
Line 5,541:
canSum(sum/2,ds) and n or Void.Skip // sum is even
}</lang>
<
zw:=[2..].tweak(isZumkellerW);
do(11){ zw.walk(20).pump(String,"%4d ".fmt).println() }
|