Zumkeller numbers: Difference between revisions

{{trans|D}}

 

V divs = [1, n]

V i = 2

I count % 8 == 0

print()

 

{{out}}

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program zumkellex641.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{Output:}}

<pre>

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

local cheating

set cheating to false

 

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

351351 459459 513513 567567 621621 671517 729729 742203 783783 793611

812889 837837 891891 908523 960687 999999 1024947 1054053 1072071 1073709

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program zumkeller4.s */

/***************************************************/

.include "../affichage.inc"

<pre>

Program start

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

{{trans|Go}}

using System.Collections.Generic;

using System.Linq;

}

}

{{out}}

<pre>The first 220 Zumkeller numbers are:

 

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

#include <cmath>

#include <vector>

// if we get here it ain't no zum

return false;

{{out}}

<pre>

=={{header|D}}==

{{trans|C#}}

import std.stdio;

 

}

}

{{out}}

<pre>The first 220 Zumkeller numbers are:

960687 999999 1024947 1054053 1072071 1073709 1095633 1108107

1145529 1162161 1198197 1224531 1270269 1307691 1324323 1378377</pre>

 

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

Seq.initInfinite((*)2>>(+)1)|>Seq.map(fun n->(n,sod n))|>Seq.filter(fun(n,g)->fN n g)|>Seq.take 40|>Seq.iter(fun(n,_)->printf "%d " n); printfn "\n"

Seq.initInfinite((*)2>>(+)1)|>Seq.filter(fun n->n%10<>5)|>Seq.map(fun n->(n,sod n))|>Seq.filter(fun(n,g)->fN n g)|>Seq.take 40|>Seq.iter(fun(n,_)->printf "%d " n); printfn "\n"

{{out}}

<pre>

81081 153153 171171 189189 207207 223839 243243 261261 279279 297297 351351 459459 513513 567567 621621 671517 729729 742203 783783 793611 812889 837837 891891 908523 960687 999999 1024947 1054053 1072071 1073709 1095633 1108107 1145529 1162161 1198197 1224531 1270269 1307691 1324323 1378377

</pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2019-10-06}}

math.primes.factors memoize prettyprint sequences ;

 

 

"First 40 odd Zumkeller numbers not ending with 5:" print

{{out}}

<pre>

 

=={{header|Go}}==

 

import "fmt"

}

fmt.Println()

 

{{out}}

=={{header|Haskell}}==

{{Trans|Python}}

import Data.List.Split (chunksOf)

import Data.Numbers.Primes (primeFactors)

 

justifyRight :: Int -> Char -> String -> String

{{Out}}

<pre>First 220 Zumkeller numbers:

14805 15015 15435 16065 16695 17325 17955 18585 19215 19305</pre>

 

=={{header|Java}}==

import java.util.ArrayList;

import java.util.Collections;

 

}

 

{{out}}

generates a stream of partitions is easily transformed into a

specialized function that prunes irrelevant partitions efficiently.

def factors:

. as $num

end

| true)

 

"First 220:", limit(220; range(2; infinite) | select(is_zumkeller)),

""

{{out}}

<pre>

 

=={{header|Julia}}==

 

function factorize(n)

println("\n\nFirst 40 odd Zumkeller numbers not ending with 5:")

printconditionalnum((n) -> isodd(n) && (string(n)[end] != '5') && iszumkeller(n), 40, 8)

<pre>

First 220 Zumkeller numbers:

=={{header|Kotlin}}==

{{trans|Java}}

import kotlin.math.sqrt

 

return divisors

}

{{out}}

<pre>First 220 Zumkeller numbers:

 

=={{header|Lobster}}==

 

// Derived from Julia and Python versions

print "\n\n40 odd Zumkeller numbers:"

printZumkellers(40, true)

{{out}}

<pre>

 

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

ZumkellerQ[n_] := Module[{d = Divisors[n], t, ds, x},

ds = Total[d];

i += 2;

];

{{out}}

<pre>{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,220,222,224,228,234,240,246,252,258,260,264,270,272,276,280,282,294,300,304,306,308,312,318,320,330,336,340,342,348,350,352,354,360,364,366,368,372,378,380,384,390,396,402,408,414,416,420,426,432,438,440,444,448,456,460,462,464,468,474,476,480,486,490,492,496,498,500,504,510,516,520,522,528,532,534,540,544,546,550,552,558,560,564,570,572,580,582,588,594,600,606,608,612,616,618,620,624,630,636,640,642,644,650,654,660,666,672,678,680,684,690,696,700,702,704,708,714,720,726,728,732,736,740,744,750,756,760,762,768,770,780,786,792,798,804,810,812,816,820,822,828,832,834,836,840,852,858,860,864,868,870,876,880,888,894,896,906,910,912,918,920,924,928,930,936,940,942,945,948,952,960,966,972,978,980,984}

=={{header|Nim}}==

{{trans|Go}}

 

template isEven(n: int): bool = (n and 1) == 0

inc count

stdout.write if count mod 8 == 0: '\n' else: ' '

 

{{out}}

960687 999999 1024947 1054053 1072071 1073709 1095633 1108107

1145529 1162161 1198197 1224531 1270269 1307691 1324323 1378377</pre>

=={{header|Pascal}}==

Using sieve for primedecomposition<BR>

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}

writeln('runtime ',(GetTickCount64-T0)/1000:8:3,' s');

END.

{{out}}

<pre>

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use feature 'say';

$n = 0; $z = '';

$z .= do { $n < 40 ? (!!($_%2 and $_%5) and is_Zumkeller($_) and ++$n and "$_ ") : last } for 1 .. Inf;

 

{{out}}

=={{header|Phix}}==

{{trans|Go}}

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(make

(for I N

(and

(=0 (% C 8))

{{out}}

<pre>

===Procedural===

Modified from a footnote at OEIS A083207 (see reference in problem text) by Charles R Greathouse IV.

 

from sympy.combinatorics.subsets import Subset

print("\n\n40 odd Zumkeller numbers:")

printZumkellers(40, True)

<pre>

220 Zumkeller numbers:

Relying on the standard Python libraries, as an alternative to importing SymPy:

 

 

from itertools import (

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>First 220 Zumkeller numbers:

{{trans|Zkl}}

 

 

(require math/number-theory)

(newline)

(tabulate "First 40 odd Zumkeller numbers not ending in 5:"

 

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

 

sub zumkeller ($range) {

$range.grep: -> $maybe {

my $zumkeller = False;

if $maybe % 2 {

$zumkeller = True

} else {

@divisors.combinations($c).map: -> $d {

}

}

 

put "\nFirst 40 odd Zumkeller numbers:\n" ~

 

# Stretch. Slow to calculate. (minutes)

put "\nFirst 40 odd Zumkeller numbers not divisible by 5:\n" ~

{{out}}

<pre>First 220 Zumkeller numbers:

=={{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.*/

if p1==p2 then return 1 /*Partition sums equal? Then X is Zum.*/

end /*part*/

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

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

 

last -= 1

end

Output:

<pre>

 

=={{header|Ruby}}==

def divisors

puts "\n#{n=40} odd Zumkeller numbers not ending with 5:"

p_enum 1.step(by: 2).lazy.select{|x| x % 5 > 0 && x.zumkeller?}.take(n)

{{out}}

<pre>220 Zumkeller numbers:

 

=={{header|Rust}}==

use std::convert::TryInto;

 

}

}

{{out}}

<pre>

 

=={{header|Sidef}}==

 

return false if n.is_prime

 

say "\nFirst 40 odd Zumkeller numbers not divisible by 5: "

{{out}}

<pre>

 

=={{header|Standard ML}}==

exception Found of string ;

 

 

end;

call loop and output - interpreter

- val Zumkellerlist = fn step => fn no5 =>

let

742203, 783783, 793611, 812889, 837837, 891891, 908523, 960687, 999999, 1024947, 1054053, 1072071, 1073709, 1095633, 1108107, 1145529,

1162161, 1198197, 1224531, 1270269, 1307691, 1324323, 1378377

 

=={{header|Swift}}==

{{trans|Go}}

 

 

extension BinaryInteger {

print("First 220 zumkeller numbers are \(Array(zums.prefix(220)))")

print("First 40 odd zumkeller numbers are \(Array(oddZums.prefix(40)))")

 

{{out}}

First 40 odd zumkeller numbers are: [945, 1575, 2205, 2835, 3465, 4095, 4725, 5355, 5775, 5985, 6435, 6615, 6825, 7245, 7425, 7875, 8085, 8415, 8505, 8925, 9135, 9555, 9765, 10395, 11655, 12285, 12705, 12915, 13545, 14175, 14805, 15015, 15435, 16065, 16695, 17325, 17955, 18585, 19215, 19305]

First 40 odd zumkeller numbers that don't end in a 5 are: [81081, 153153, 171171, 189189, 207207, 223839, 243243, 261261, 279279, 297297, 351351, 459459, 513513, 567567, 621621, 671517, 729729, 742203, 783783, 793611, 812889, 837837, 891891, 908523, 960687, 999999, 1024947, 1054053, 1072071, 1073709, 1095633, 1108107, 1145529, 1162161, 1198197, 1224531, 1270269, 1307691, 1324323, 1378377]</pre>

 

=={{header|Visual Basic .NET}}==

{{trans|C#}}

Function GetDivisors(n As Integer) As List(Of Integer)

Dim divs As New List(Of Integer) From {

End While

End Sub

{{out}}

<pre>The first 220 Zumkeller numbers are:

960687 999999 1024947 1054053 1072071 1073709 1095633 1108107

1145529 1162161 1198197 1224531 1270269 1307691 1324323 1378377</pre>

 

=={{header|Wren}}==

{{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 "io" for Stdout

 

i = i + 2

}

 

{{out}}

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

}

canSum(sum/2,ds) and n or Void.Skip // sum is even

zw:=[2..].tweak(isZumkellerW);

do(11){ zw.walk(20).pump(String,"%4d ".fmt).println() }

println("\nThe first 40 odd Zumkeller numbers which don't end in 5 are:");

zw:=[3..*, 2].tweak(fcn(n){ if(n%5) isZumkellerW(n) else Void.Skip });

{{out}}

<pre style="font-size:83%">