aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Data commit

Browse source
This commit is contained in:
Ingy döt Net 2023-07-01 11:58:00 -04:00
parent 7387c8f97b
commit cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Task/Weird-numbers/00-META.yaml Normal file
View file

@ -0,0 +1,2 @@
---
from: http://rosettacode.org/wiki/Weird_numbers

29
Task/Weird-numbers/00-TASK.txt Normal file
View file

@ -0,0 +1,29 @@
In number theory, a [[wp:weird number|weird number]] is a natural number that is [[wp:abundant number|abundant]] but ''not'' [[wp:semiperfect number|semiperfect]] (and therefore not [[wp:perfect number|perfect]] either).
In other words, the sum of the [[wp:Divisor#Further_notions_and_facts|proper divisors]] of the number (divisors including 1 but not itself) is greater than the number itself (the number is ''abundant''), but no subset of those divisors sums to the number itself (the number is not ''semiperfect'').
For example:
* '''12''' is ''not'' a weird number.
** It is abundant; its proper divisors '''1, 2, 3, 4, 6''' sum to '''16''' (which ''is'' > 12),
** but it ''is'' semiperfect, e.g.:     '''6 + 4 + 2 == 12'''.
* '''70''' ''is'' a weird number.
** It is abundant; its proper divisors '''1, 2, 5, 7, 10, 14, 35''' sum to '''74''' (which ''is'' > 70),
** and there is no subset of proper divisors that sum to '''70'''.
;Task:
Find and display, here on this page, the first '''25''' weird numbers.
;Related tasks:
:* [[Abundant,_deficient_and_perfect_number_classifications|Abundant, deficient and perfect number classifications]]
:* [[Proper_divisors|Proper divisors]]
;See also:
:* [[oeis:A006037|OEIS: A006037 weird numbers]]
:* [[wp:weird number|Wikipedia: weird number]]
:* [http://mathworld.wolfram.com/WeirdNumber.html MathWorld: weird number]
<br>

49
Task/Weird-numbers/11l/weird-numbers.11l Normal file
View file

@ -0,0 +1,49 @@
F divisors(n)
V divs = [1]
[Int] divs2
V i = 2
L i * i <= n
I n % i == 0
V j = n I/ i
divs [+]= i
I i != j
divs2 [+]= j
i++
R divs2 [+] reversed(divs)
F abundant(n, divs)
R sum(divs) > n
F semiperfect(n, divs) -> Bool
I !divs.empty
V h = divs[0]
V t = divs[1..]
I n < h
R semiperfect(n, t)
E
R n == h | semiperfect(n - h, t) | semiperfect(n, t)
E
R 0B
F sieve(limit)
V w = [0B] * limit
L(i) (2 .< limit).step(2)
I w[i]
L.continue
V divs = divisors(i)
I !abundant(i, divs)
w[i] = 1B
E I semiperfect(i, divs)
L(j) (i .< limit).step(i)
w[j] = 1B
R w
V w = sieve(17'000)
V count = 0
print(‘The first 25 weird numbers:’)
L(n) (2..).step(2)
I !w[n]
print(n, end' ‘ ’)
count++
I count == 25
L.break

71
Task/Weird-numbers/ALGOL-68/weird-numbers.alg Normal file
View file

@ -0,0 +1,71 @@
BEGIN # find wierd numbers - abundant but not semiperfect numbers - translation of Go #
# returns the divisors of n in descending order #
PROC divisors = ( INT n )[]INT:
BEGIN
INT max divs = 2 * ENTIER sqrt( n );
[ 1 : max divs ]INT divs;
[ 1 : max divs ]INT divs2;
INT d pos := 0, d2 pos := 0;
divs[ d pos +:= 1 ] := 1;
FOR i FROM 2 WHILE i * i <= n DO
IF n MOD i = 0 THEN
INT j = n OVER i;
divs[ d pos +:= 1 ] := i;
IF i /= j THEN divs2[ d2 pos +:= 1 ] := j FI
FI
OD;
FOR i FROM d pos BY -1 WHILE i > 0 DO
divs2[ d2 pos +:= 1 ] := divs[ i ]
OD;
divs2[ 1 : d2 pos ]
END # divisors # ;
# returns TRUE if n with divisors divs, is abundant, FALSE otherwise #
PROC abundant = ( INT n, []INT divs )BOOL:
BEGIN
INT sum := 0;
FOR i FROM LWB divs TO UPB divs DO sum +:= divs[ i ] OD;
sum > n
END # abundant # ;
# returns TRUE if n with divisors divs, is semiperfect, FALSE otherwise #
PROC semiperfect = ( INT n, []INT divs, INT lb, ub )BOOL:
IF ub < lb
THEN FALSE
ELIF INT h = divs[ lb ];
n < h
THEN semiperfect( n, divs, lb + 1, ub )
ELIF n = h
THEN TRUE
ELIF semiperfect( n - h, divs, lb + 1, ub )
THEN TRUE
ELSE semiperfect( n, divs, lb + 1, ub )
FI # semiperfect # ;
# returns a sieve where FALSE = abundant and not semiperfect #
PROC sieve = ( INT limit )[]BOOL:
BEGIN # Only interested in even numbers >= 2 #
[ 1 : limit ]BOOL w; FOR i FROM 1 TO limit DO w[ i ] := FALSE OD;
FOR i FROM 2 BY 2 TO limit DO
IF NOT w[ i ] THEN
[]INT divs = divisors( i );
IF NOT abundant( i, divs ) THEN
w[ i ] := TRUE
ELIF semiperfect( i, divs, LWB divs, UPB divs ) THEN
FOR j FROM i BY i TO limit DO w[ j ] := TRUE OD
FI
FI
OD;
w
END # sieve # ;
BEGIN # task #
[]BOOL w = sieve( 17 000 );
INT count := 0;
INT max = 25;
print( ( "The first 25 weird numbers are:", newline ) );
FOR n FROM 2 BY 2 WHILE count < max DO
IF NOT w[ n ] THEN
print( ( whole( n, 0 ), " " ) );
count +:= 1
FI
OD;
print( ( newline ) )
END
END

172
Task/Weird-numbers/AppleScript/weird-numbers-1.applescript Normal file
View file

@ -0,0 +1,172 @@
on run
take(25, weirds())
-- Gets there, but takes about 6 seconds on this system,
-- (logging intermediates through the Messages channel, for the impatient :-)
end run
-- weirds :: Gen [Int]
on weirds()
script
property x : 1
property v : 0
on |λ|()
repeat until isWeird(x)
set x to 1 + x
end repeat
set v to x
log v
set x to 1 + x
return v
end |λ|
end script
end weirds
-- isWeird :: Int -> Bool
on isWeird(n)
set ds to descProperDivisors(n)
set d to sum(ds) - n
0 < d and not hasSum(d, ds)
end isWeird
-- hasSum :: Int -> [Int] -> Bool
on hasSum(n, xs)
if {} ≠ xs then
set h to item 1 of xs
set t to rest of xs
if n < h then
hasSum(n, t)
else
n = h or hasSum(n - h, t) or hasSum(n, t)
end if
else
false
end if
end hasSum
-- GENERIC ------------------------------------------------
-- descProperDivisors :: Int -> [Int]
on descProperDivisors(n)
if n = 1 then
{1}
else
set realRoot to n ^ (1 / 2)
set intRoot to realRoot as integer
set blnPerfect to intRoot = realRoot
-- isFactor :: Int -> Bool
script isFactor
on |λ|(x)
n mod x = 0
end |λ|
end script
-- Factors up to square root of n,
set lows to filter(isFactor, enumFromTo(1, intRoot))
-- and cofactors of these beyond the square root,
-- integerQuotient :: Int -> Int
script integerQuotient
on |λ|(x)
(n / x) as integer
end |λ|
end script
set t to rest of lows
if blnPerfect then
set xs to t
else
set xs to lows
end if
map(integerQuotient, t) & (reverse of xs)
end if
end descProperDivisors
-- enumFromTo :: (Int, Int) -> [Int]
on enumFromTo(m, n)
if m ≤ n then
set lst to {}
repeat with i from m to n
set end of lst to i
end repeat
return lst
else
return {}
end if
end enumFromTo
-- filter :: (a -> Bool) -> [a] -> [a]
on filter(f, xs)
tell mReturn(f)
set lst to {}
set lng to length of xs
repeat with i from 1 to lng
set v to item i of xs
if |λ|(v, i, xs) then set end of lst to v
end repeat
return lst
end tell
end filter
-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
tell mReturn(f)
set v to startValue
set lng to length of xs
repeat with i from 1 to lng
set v to |λ|(v, item i of xs, i, xs)
end repeat
return v
end tell
end foldl
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
tell mReturn(f)
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to |λ|(item i of xs, i, xs)
end repeat
return lst
end tell
end map
-- sum :: [Num] -> Num
on sum(xs)
script add
on |λ|(a, b)
a + b
end |λ|
end script
foldl(add, 0, xs)
end sum
-- take :: Int -> Gen [a] -> [a]
on take(n, xs)
set ys to {}
repeat with i from 1 to n
set v to xs's |λ|()
if missing value is v then
return ys
else
set end of ys to v
end if
end repeat
return ys
end take
-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
if script is class of f then
f
else
script
property |λ| : f
end script
end if
end mReturn

102
Task/Weird-numbers/AppleScript/weird-numbers-2.applescript Normal file
View file

@ -0,0 +1,102 @@
-- Sum n's proper divisors.
on aliquotSum(n)
if (n < 2) then return 0
set sum to 1
set sqrt to n ^ 0.5
set limit to sqrt div 1
if (limit = sqrt) then
set sum to sum + limit
set limit to limit - 1
end if
repeat with i from 2 to limit
if (n mod i is 0) then set sum to sum + i + n div i
end repeat
return sum
end aliquotSum
-- Return n's proper divisors.
on properDivisors(n)
set output to {}
if (n > 1) then
set sqrt to n ^ 0.5
set limit to sqrt div 1
if (limit = sqrt) then
set end of output to limit
set limit to limit - 1
end if
repeat with i from limit to 2 by -1
if (n mod i is 0) then
set beginning of output to i
set end of output to n div i
end if
end repeat
set beginning of output to 1
end if
return output
end properDivisors
-- Does a subset of the given list of numbers add up to the target value?
on subsetOf:numberList sumsTo:target
script o
property lst : numberList
property someNegatives : false
on ssp(target, i)
repeat while (i > 1)
set n to item i of my lst
set i to i - 1
if ((n = target) or (((n < target) or (someNegatives)) and (ssp(target - n, i)))) then return true
end repeat
return (target = beginning of my lst)
end ssp
end script
-- The search can be more efficient if it's known the list contains no negatives.
repeat with n in o's lst
if (n < 0) then
set o's someNegatives to true
exit repeat
end if
end repeat
return o's ssp(target, count o's lst)
end subsetOf:sumsTo:
-- Is n a weird number?
on isWeird(n)
-- Yes if its aliquot sum's greater than it and no subset of its proper divisors adds up to it.
-- Using aliquotSum() to get the divisor sum and then calling properDivisors() too if a list's actually
-- needed is generally faster than calling properDivisors() in the first place and summing the result.
set sum to aliquotSum(n)
if (sum > n) then
set divisors to properDivisors(n)
-- Check that no subset sums to the smaller (usually the latter) of n and sum - n.
tell (sum - n) to if (it < n) then set n to it
return (not (my subsetOf:divisors sumsTo:n))
else
return false
end if
end isWeird
-- Task code:
on weirdNumbers(target)
script o
property weirds : {}
end script
set n to 2
set counter to 0
repeat until (counter = target)
if (isWeird(n)) then
set end of o's weirds to n
set counter to counter + 1
end if
set n to n + 1
end repeat
return o's weirds
end weirdNumbers
weirdNumbers(25)

1
Task/Weird-numbers/AppleScript/weird-numbers-3.applescript Normal file
View file

@ -0,0 +1 @@
{70, 836, 4030, 5830, 7192, 7912, 9272, 10430, 10570, 10792, 10990, 11410, 11690, 12110, 12530, 12670, 13370, 13510, 13790, 13930, 14770, 15610, 15890, 16030, 16310}

81
Task/Weird-numbers/C++/weird-numbers.cpp Normal file
View file

@ -0,0 +1,81 @@
#include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>
std::vector<int> divisors(int n) {
std::vector<int> divs = { 1 };
std::vector<int> divs2;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
int j = n / i;
divs.push_back(i);
if (i != j) {
divs2.push_back(j);
}
}
}
std::copy(divs.cbegin(), divs.cend(), std::back_inserter(divs2));
return divs2;
}
bool abundant(int n, const std::vector<int> &divs) {
return std::accumulate(divs.cbegin(), divs.cend(), 0) > n;
}
template<typename IT>
bool semiperfect(int n, const IT &it, const IT &end) {
if (it != end) {
auto h = *it;
auto t = std::next(it);
if (n < h) {
return semiperfect(n, t, end);
} else {
return n == h
|| semiperfect(n - h, t, end)
|| semiperfect(n, t, end);
}
} else {
return false;
}
}
template<typename C>
bool semiperfect(int n, const C &c) {
return semiperfect(n, std::cbegin(c), std::cend(c));
}
std::vector<bool> sieve(int limit) {
// false denotes abundant and not semi-perfect.
// Only interested in even numbers >= 2
std::vector<bool> w(limit);
for (int i = 2; i < limit; i += 2) {
if (w[i]) continue;
auto divs = divisors(i);
if (!abundant(i, divs)) {
w[i] = true;
} else if (semiperfect(i, divs)) {
for (int j = i; j < limit; j += i) {
w[j] = true;
}
}
}
return w;
}
int main() {
auto w = sieve(17000);
int count = 0;
int max = 25;
std::cout << "The first 25 weird numbers:";
for (int n = 2; count < max; n += 2) {
if (!w[n]) {
std::cout << n << ' ';
count++;
}
}
std::cout << '\n';
return 0;
}

80
Task/Weird-numbers/C-sharp/weird-numbers.cs Normal file
View file

@ -0,0 +1,80 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace WeirdNumbers {
class Program {
static List<int> Divisors(int n) {
List<int> divs = new List<int> { 1 };
List<int> divs2 = new List<int>();
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
int j = n / i;
divs.Add(i);
if (i != j) {
divs2.Add(j);
}
}
}
divs.Reverse();
divs2.AddRange(divs);
return divs2;
}
static bool Abundant(int n, List<int> divs) {
return divs.Sum() > n;
}
static bool Semiperfect(int n, List<int> divs) {
if (divs.Count > 0) {
var h = divs[0];
var t = divs.Skip(1).ToList();
if (n < h) {
return Semiperfect(n, t);
} else {
return n == h
|| Semiperfect(n - h, t)
|| Semiperfect(n, t);
}
} else {
return false;
}
}
static List<bool> Sieve(int limit) {
// false denotes abundant and not semi-perfect.
// Only interested in even numbers >= 2
bool[] w = new bool[limit];
for (int i = 2; i < limit; i += 2) {
if (w[i]) continue;
var divs = Divisors(i);
if (!Abundant(i, divs)) {
w[i] = true;
} else if (Semiperfect(i, divs)) {
for (int j = i; j < limit; j += i) {
w[j] = true;
}
}
}
return w.ToList();
}
static void Main() {
var w = Sieve(17_000);
int count = 0;
int max = 25;
Console.WriteLine("The first 25 weird numbers:");
for (int n = 2; count < max; n += 2) {
if (!w[n]) {
Console.Write("{0} ", n);
count++;
}
}
Console.WriteLine();
}
}
}

113
Task/Weird-numbers/C/weird-numbers.c Normal file
View file

@ -0,0 +1,113 @@
#include "stdio.h"
#include "stdlib.h"
#include "stdbool.h"
#include "string.h"
struct int_a {
int *ptr;
size_t size;
};
struct int_a divisors(int n) {
int *divs, *divs2, *out;
int i, j, c1 = 0, c2 = 0;
struct int_a array;
divs = malloc(n * sizeof(int) / 2);
divs2 = malloc(n * sizeof(int) / 2);
divs[c1++] = 1;
for (i = 2; i * i <= n; i++) {
if (n % i == 0) {
j = n / i;
divs[c1++] = i;
if (i != j) {
divs2[c2++] = j;
}
}
}
out = malloc((c1 + c2) * sizeof(int));
for (int i = 0; i < c2; i++) {
out[i] = divs2[i];
}
for (int i = 0; i < c1; i++) {
out[c2 + i] = divs[c1 - i - 1];
}
array.ptr = out;
array.size = c1 + c2;
free(divs);
free(divs2);
return array;
}
bool abundant(int n, struct int_a divs) {
int sum = 0;
int i;
for (i = 0; i < divs.size; i++) {
sum += divs.ptr[i];
}
return sum > n;
}
bool semiperfect(int n, struct int_a divs) {
if (divs.size > 0) {
int h = *divs.ptr;
int *t = divs.ptr + 1;
struct int_a ta;
ta.ptr = t;
ta.size = divs.size - 1;
if (n < h) {
return semiperfect(n, ta);
} else {
return n == h
|| semiperfect(n - h, ta)
|| semiperfect(n, ta);
}
} else {
return false;
}
}
bool *sieve(int limit) {
bool *w = calloc(limit, sizeof(bool));
struct int_a divs;
int i, j;
for (i = 2; i < limit; i += 2) {
if (w[i]) continue;
divs = divisors(i);
if (!abundant(i, divs)) {
w[i] = true;
} else if (semiperfect(i, divs)) {
for (j = i; j < limit; j += i) {
w[j] = true;
}
}
}
free(divs.ptr);
return w;
}
int main() {
bool *w = sieve(17000);
int count = 0;
int max = 25;
int n;
printf("The first 25 weird numbers:\n");
for (n = 2; count < max; n += 2) {
if (!w[n]) {
printf("%d ", n);
count++;
}
}
printf("\n");
free(w);
return 0;
}

91
Task/Weird-numbers/Crystal/weird-numbers.crystal Normal file
View file

@ -0,0 +1,91 @@
def divisors(n : Int32) : Array(Int32)
divs = [1]
divs2 = [] of Int32
i = 2
while i * i < n
if n % i == 0
j = n // i
divs << i
divs2 << j if i != j
end
i += 1
end
i = divs.size - 1
# TODO: Use reverse
while i >= 0
divs2 << divs[i]
i -= 1
end
divs2
end
def abundant(n : Int32, divs : Array(Int32)) : Bool
divs.sum > n
end
def semiperfect(n : Int32, divs : Array(Int32)) : Bool
if divs.size > 0
h = divs[0]
t = divs[1..]
return n < h ? semiperfect(n, t) : n == h || semiperfect(n - h, t) || semiperfect(n, t)
end
return false
end
def sieve(limit : Int32) : Array(Bool)
# false denotes abundant and not semi-perfect.
# Only interested in even numbers >= 2
w = Array(Bool).new(limit, false) # An array filled with 'false'
i = 2
while i < limit
if !w[i]
divs = divisors i
if !abundant(i, divs)
w[i] = true
elsif semiperfect(i, divs)
j = i
while j < limit
w[j] = true
j += i
end
end
end
i += 2
end
w
end
def main
w = sieve 17000
count = 0
max = 25
print "The first 25 weird numbers are: "
n = 2
while count < max
if !w[n]
print "#{n} "
count += 1
end
n += 2
end
puts "\n"
end
require "benchmark"
puts Benchmark.measure { main }

80
Task/Weird-numbers/D/weird-numbers.d Normal file
View file

@ -0,0 +1,80 @@
import std.algorithm;
import std.array;
import std.stdio;
int[] divisors(int n) {
int[] divs = [1];
int[] divs2;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
int j = n / i;
divs ~= i;
if (i != j) {
divs2 ~= j;
}
}
}
divs2 ~= divs.reverse;
return divs2;
}
bool abundant(int n, int[] divs) {
return divs.sum() > n;
}
bool semiperfect(int n, int[] divs) {
// This algorithm is O(2^N) for N == divs.length when number is not semiperfect.
// Comparing with (divs.sum < n) instead (divs.length==0) removes unnecessary
// recursive binary tree branches.
auto s = divs.sum;
if(s == n)
return true;
else if ( s<n )
return false;
else {
auto h = divs[0];
auto t = divs[1..$];
if (n < h) {
return semiperfect(n, t);
} else {
return n == h
// Supossin h is part of the sum
|| semiperfect(n - h, t)
// Supossin h is not part of the sum
|| semiperfect(n, t);
}
}
}
bool[] sieve(int limit) {
// false denotes abundant and not semi-perfect.
// Only interested in even numbers >= 2
auto w = uninitializedArray!(bool[])(limit);
w[] = false;
for (int i = 2; i < limit; i += 2) {
if (w[i]) continue;
auto divs = divisors(i);
if (!abundant(i, divs)) {
w[i] = true;
} else if (semiperfect(i, divs)) {
for (int j = i; j < limit; j += i) {
w[j] = true;
}
}
}
return w;
}
void main() {
auto w = sieve(17_000);
int count = 0;
int max = 25;
writeln("The first 25 weird numbers:");
for (int n = 2; count < max; n += 2) {
if (!w[n]) {
write(n, ' ');
count++;
}
}
writeln;
}

32
Task/Weird-numbers/F-Sharp/weird-numbers.fs Normal file
View file

@ -0,0 +1,32 @@
let divisors n = [1..n/2] |> List.filter (fun x->n % x = 0)
let abundant (n:int) divs = Seq.sum(divs) > n
let rec semiperfect (n:int) (divs:List<int>) =
if divs.Length > 0 then
let h = divs.Head
let t = divs.Tail
if n < h then
semiperfect n t
else
n = h || (semiperfect (n - h) t) || (semiperfect n t)
else false
let weird n =
let d = divisors n
if abundant n d then
not(semiperfect n d)
else
false
[<EntryPoint>]
let main _ =
let mutable i = 1
let mutable count = 0
while (count < 25) do
if (weird i) then
count <- count + 1
printf "%d -> %d\n" count i
i <- i + 1
0 // return an integer exit code

27
Task/Weird-numbers/Factor/weird-numbers.factor Normal file
View file

@ -0,0 +1,27 @@
USING: combinators.short-circuit io kernel lists lists.lazy
locals math math.primes.factors prettyprint sequences ;
IN: rosetta-code.weird-numbers
:: has-sum? ( n seq -- ? )
seq [ f ] [
unclip-slice :> ( xs x )
n x < [ n xs has-sum? ] [
{
[ n x = ]
[ n x - xs has-sum? ]
[ n xs has-sum? ]
} 0||
] if
] if-empty ;
: weird? ( n -- ? )
dup divisors but-last reverse
{ [ sum < ] [ has-sum? not ] } 2&& ;
: weirds ( -- list ) 1 lfrom [ weird? ] lfilter ;
: weird-numbers-demo ( -- )
"First 25 weird numbers:" print
25 weirds ltake list>array . ;
MAIN: weird-numbers-demo

54
Task/Weird-numbers/FreeBASIC/weird-numbers.basic Normal file
View file

@ -0,0 +1,54 @@
Function GetFactors(n As Long,r() As Long) As Long
Redim r(0)
r(0)=1
Dim As Long count,acc
For z As Long=2 To n\2
If n Mod z=0 Then
count+=1:redim preserve r(0 to count)
r(count)=z
acc+=z
End If
Next z
Return 1+acc
End Function
sub sumcombinations(arr() As Long,n As Long,r As Long,index As Long,_data() As Long,i As Long,Byref ans As Long,ref As Long)
Dim As Long acc
If index=r Then
For j As Long=0 To r-1
acc+=_data(j)
If acc=ref Then ans=1:Return
If acc>ref then return
Next j
Return
End If
If i>=n Or ans<>0 Then Return
_data(index) = arr(i)
sumcombinations(arr(),n,r,index + 1,_data(),i+1,ans,ref)
sumcombinations(arr(),n,r,index,_data(),i+1,ans,ref)
End sub
Function IsWeird(u() As Long,num As Long) As Long
Redim As Long d()
Dim As Long ans
For r As Long=2 To Ubound(u)
Redim d(r)
ans=0
sumcombinations(u(),Ubound(u)+1,r,0,d(),0,ans,num)
If ans =1 Then Return 0
Next r
Return 1
End Function
Redim As Long u()
Dim As Long SumFactors,number=2,count
Do
number+=2
SumFactors=GetFactors(number,u())
If SumFactors>number Then
If IsWeird(u(),number) Then Print number;" ";:count+=1
End If
Loop Until count=25
Print
Print "first 25 done"
Sleep

78
Task/Weird-numbers/Go/weird-numbers.go Normal file
View file

@ -0,0 +1,78 @@
package main
import "fmt"
func divisors(n int) []int {
divs := []int{1}
divs2 := []int{}
for i := 2; i*i <= n; i++ {
if n%i == 0 {
j := n / i
divs = append(divs, i)
if i != j {
divs2 = append(divs2, j)
}
}
}
for i := len(divs) - 1; i >= 0; i-- {
divs2 = append(divs2, divs[i])
}
return divs2
}
func abundant(n int, divs []int) bool {
sum := 0
for _, div := range divs {
sum += div
}
return sum > n
}
func semiperfect(n int, divs []int) bool {
le := len(divs)
if le > 0 {
h := divs[0]
t := divs[1:]
if n < h {
return semiperfect(n, t)
} else {
return n == h || semiperfect(n-h, t) || semiperfect(n, t)
}
} else {
return false
}
}
func sieve(limit int) []bool {
// false denotes abundant and not semi-perfect.
// Only interested in even numbers >= 2
w := make([]bool, limit)
for i := 2; i < limit; i += 2 {
if w[i] {
continue
}
divs := divisors(i)
if !abundant(i, divs) {
w[i] = true
} else if semiperfect(i, divs) {
for j := i; j < limit; j += i {
w[j] = true
}
}
}
return w
}
func main() {
w := sieve(17000)
count := 0
const max = 25
fmt.Println("The first 25 weird numbers are:")
for n := 2; count < max; n += 2 {
if !w[n] {
fmt.Printf("%d ", n)
count++
}
}
fmt.Println()
}

30
Task/Weird-numbers/Haskell/weird-numbers.hs Normal file
View file

@ -0,0 +1,30 @@
weirds :: [Int]
weirds = filter abundantNotSemiperfect [1 ..]
abundantNotSemiperfect :: Int -> Bool
abundantNotSemiperfect n =
let ds = descProperDivisors n
d = sum ds - n
in 0 < d && not (hasSum d ds)
hasSum :: Int -> [Int] -> Bool
hasSum _ [] = False
hasSum n (x:xs)
| n < x = hasSum n xs
| otherwise = (n == x) || hasSum (n - x) xs || hasSum n xs
descProperDivisors
:: Integral a
=> a -> [a]
descProperDivisors n =
let root = (floor . sqrt) (fromIntegral n :: Double)
lows = filter ((0 ==) . rem n) [root,root - 1 .. 1]
factors
| n == root ^ 2 = tail lows
| otherwise = lows
in tail $ reverse (quot n <$> lows) ++ factors
main :: IO ()
main =
(putStrLn . unlines) $
zipWith (\i x -> show i ++ (" -> " ++ show x)) [1 ..] (take 25 weirds)

41
Task/Weird-numbers/J/weird-numbers.j Normal file
View file

@ -0,0 +1,41 @@
factor=: [: }: [: , [: */&> [: { [: <@(^ i.@>:)/"1 [: |: __&q:
classify=: 3 : 0
weird =: perfect =: deficient =: abundant =: i. 0
a=: (i. -. 0 , deficient =: 1 , i.&.:(p:inv)) y NB. a are potential semi-perfect numbers
for_n. a do.
if. n e. a do.
factors=. factor n
sf =. +/ factors
if. sf < n do.
deficient =: deficient , n
else.
if. n < sf do.
abundant=: abundant , n
else.
perfect =: perfect , n
a =: a -. (2+i.)@<.&.(%&n) y NB. remove multiples of perfect numbers
continue.
end.
NB. compute sums of subsets to detect semiperfection
NB. the following algorithm correctly finds weird numbers less than 20000
NB. remove large terms necessary for the sum to reduce the Catalan tally of sets
factors =. /:~ factors NB. ascending sort
NB. if the sum of the length one outfixes is less n then the factor is required in the semiperfect set.
i_required =. n (1 i.~ (>(1+/\.]))) factors
target =. n - +/ i_required }. factors
t =. i_required {. factors
NB. work in chunks of 2^16 to reduce memory requirement
sp =. target e. ; (,:~2^16) <@([: +/"1 t #~ (_ ,(#t)) {. #:);.3 i. 2 ^ # t
if. sp do.
a =: a -. (2+i.)@<.&.(%&n) y NB. remove multiples of semi perfect numbers
else.
weird =: weird , n
a =: a -. n
end.
end.
end.
end.
a =: a -. deficient
weird
)

73
Task/Weird-numbers/Java/weird-numbers.java Normal file
View file

@ -0,0 +1,73 @@
import java.util.ArrayList;
import java.util.List;
public class WeirdNumbers {
public static void main(String[] args) {
int n = 2;
// n += 2 : No odd weird numbers < 10^21
for ( int count = 1 ; count <= 25 ; n += 2 ) {
if ( isWeird(n) ) {
System.out.printf("w(%d) = %d%n", count, n);
count++;
}
}
}
private static boolean isWeird(int n) {
List<Integer> properDivisors = getProperDivisors(n);
return isAbundant(properDivisors, n) && ! isSemiPerfect(properDivisors, n);
}
private static boolean isAbundant(List<Integer> divisors, int n) {
int divisorSum = divisors.stream().mapToInt(i -> i.intValue()).sum();
return divisorSum > n;
}
// Use Dynamic Programming
private static boolean isSemiPerfect(List<Integer> divisors, int sum) {
int size = divisors.size();
// The value of subset[i][j] will be true if there is a subset of divisors[0..j-1] with sum equal to i
boolean subset[][] = new boolean[sum+1][size+1];
// If sum is 0, then answer is true
for (int i = 0; i <= size; i++) {
subset[0][i] = true;
}
// If sum is not 0 and set is empty, then answer is false
for (int i = 1; i <= sum; i++) {
subset[i][0] = false;
}
// Fill the subset table in bottom up manner
for ( int i = 1 ; i <= sum ; i++ ) {
for ( int j = 1 ; j <= size ; j++ ) {
subset[i][j] = subset[i][j-1];
int test = divisors.get(j-1);
if ( i >= test ) {
subset[i][j] = subset[i][j] || subset[i - test][j-1];
}
}
}
return subset[sum][size];
}
private static final List<Integer> getProperDivisors(int number) {
List<Integer> divisors = new ArrayList<Integer>();
long sqrt = (long) Math.sqrt(number);
for ( int i = 1 ; i <= sqrt ; i++ ) {
if ( number % i == 0 ) {
divisors.add(i);
int div = number / i;
if ( div != i && div != number ) {
divisors.add(div);
}
}
}
return divisors;
}
}

115
Task/Weird-numbers/JavaScript/weird-numbers.js Normal file
View file

@ -0,0 +1,115 @@
(() => {
'use strict';
// main :: IO ()
const main = () =>
take(25, weirds());
// weirds :: Gen [Int]
function* weirds() {
let
x = 1,
i = 1;
while (true) {
x = until(isWeird, succ, x)
console.log(i.toString() + ' -> ' + x)
yield x;
x = 1 + x;
i = 1 + i;
}
}
// isWeird :: Int -> Bool
const isWeird = n => {
const
ds = descProperDivisors(n),
d = sum(ds) - n;
return 0 < d && !hasSum(d, ds)
};
// hasSum :: Int -> [Int] -> Bool
const hasSum = (n, xs) => {
const go = (n, xs) =>
0 < xs.length ? (() => {
const
h = xs[0],
t = xs.slice(1);
return n < h ? (
go(n, t)
) : (
n == h || hasSum(n - h, t) || hasSum(n, t)
);
})() : false;
return go(n, xs);
};
// descProperDivisors :: Int -> [Int]
const descProperDivisors = n => {
const
rRoot = Math.sqrt(n),
intRoot = Math.floor(rRoot),
blnPerfect = rRoot === intRoot,
lows = enumFromThenTo(intRoot, intRoot - 1, 1)
.filter(x => (n % x) === 0);
return (
reverse(lows)
.slice(1)
.map(x => n / x)
).concat((blnPerfect ? tail : id)(lows))
};
// GENERIC FUNCTIONS ----------------------------
// enumFromThenTo :: Int -> Int -> Int -> [Int]
const enumFromThenTo = (x1, x2, y) => {
const d = x2 - x1;
return Array.from({
length: Math.floor(y - x2) / d + 2
}, (_, i) => x1 + (d * i));
};
// id :: a -> a
const id = x => x;
// reverse :: [a] -> [a]
const reverse = xs =>
'string' !== typeof xs ? (
xs.slice(0).reverse()
) : xs.split('').reverse().join('');
// succ :: Enum a => a -> a
const succ = x => 1 + x;
// sum :: [Num] -> Num
const sum = xs => xs.reduce((a, x) => a + x, 0);
// tail :: [a] -> [a]
const tail = xs => 0 < xs.length ? xs.slice(1) : [];
// take :: Int -> [a] -> [a]
// take :: Int -> String -> String
const take = (n, xs) =>
'GeneratorFunction' !== xs.constructor.constructor.name ? (
xs.slice(0, n)
) : [].concat.apply([], Array.from({
length: n
}, () => {
const x = xs.next();
return x.done ? [] : [x.value];
}));
// until :: (a -> Bool) -> (a -> a) -> a -> a
const until = (p, f, x) => {
let v = x;
while (!p(v)) v = f(v);
return v;
};
// MAIN ---
return main();
})();

55
Task/Weird-numbers/Jq/weird-numbers.jq Normal file
View file

@ -0,0 +1,55 @@
# unordered
def proper_divisors:
. as $n
| if $n > 1 then 1,
( range(2; 1 + (sqrt|floor)) as $i
| if ($n % $i) == 0 then $i,
(($n / $i) | if . == $i then empty else . end)
else empty
end)
else empty
end;
# Is n semiperfect given that divs are the proper divisors
def semiperfect(n; divs):
(divs|length) as $le
| if $le == 0 then false
else divs[0] as $h
| if n == $h then true
elif $le == 1 then false
else divs[1:] as $t
| if n < $h then semiperfect(n; $t)
else semiperfect(n-$h; $t) or semiperfect(n; $t)
end
end
end ;
def sieve(limit):
# 'false' denotes abundant and not semi-perfect.
# Only interested in even numbers >= 2
(reduce range(6; limit; 6) as $j ([]; .[$j] = true)) # eliminates multiples of 3
| reduce range(2; limit; 2) as $i (.;
if (.[$i]|not)
then [$i|proper_divisors] as $divs
| ($divs | add) as $sum
| if $sum <= $i
then .[$i] = true
elif (semiperfect($sum-$i; $divs))
then reduce range($i; limit; $i) as $j (.; .[$j] = true)
else .
end
else .
end) ;
# Print up to $max weird numbers based on the given sieve size, $limit.
def task($limit; $max):
sieve($limit) as $w
| def weirds:
range(2; $w|length; 2) | select($w[.]|not);
# collect into an array for ease of counting
[limit($max; weirds)]
| "The first \(length) weird numbers are:", . ;
# The parameters should be set on the command line:
task($sieve; $limit)

44
Task/Weird-numbers/Julia/weird-numbers.julia Normal file
View file

@ -0,0 +1,44 @@
using Primes
function nosuchsum(revsorted, num)
if sum(revsorted) < num
return true
end
for (i, n) in enumerate(revsorted)
if n > num
continue
elseif n == num
return false
elseif !nosuchsum(revsorted[i+1:end], num - n)
return false
end
end
true
end
function isweird(n)
if n < 70 || isodd(n)
return false
else
f = [one(n)]
for (p, x) in factor(n)
f = reduce(vcat, [f*p^i for i in 1:x], init=f)
end
pop!(f)
return sum(f) > n && nosuchsum(sort(f, rev=true), n)
end
end
function testweird(N)
println("The first $N weird numbers are: ")
count, n = 0, 69
while count < N
if isweird(n)
count += 1
print("$n ")
end
n += 1
end
end
testweird(25)

65
Task/Weird-numbers/Kotlin/weird-numbers.kotlin Normal file
View file

@ -0,0 +1,65 @@
// Version 1.3.21
fun divisors(n: Int): List<Int> {
val divs = mutableListOf(1)
val divs2 = mutableListOf<Int>()
var i = 2
while (i * i <= n) {
if (n % i == 0) {
val j = n / i
divs.add(i)
if (i != j) divs2.add(j)
}
i++
}
divs2.addAll(divs.asReversed())
return divs2
}
fun abundant(n: Int, divs: List<Int>) = divs.sum() > n
fun semiperfect(n: Int, divs: List<Int>): Boolean {
if (divs.size > 0) {
val h = divs[0]
val t = divs.subList(1, divs.size)
if (n < h) {
return semiperfect(n, t)
} else {
return n == h || semiperfect(n-h, t) || semiperfect(n, t)
}
} else {
return false
}
}
fun sieve(limit: Int): BooleanArray {
// false denotes abundant and not semi-perfect.
// Only interested in even numbers >= 2
val w = BooleanArray(limit)
for (i in 2 until limit step 2) {
if (w[i]) continue
val divs = divisors(i)
if (!abundant(i, divs)) {
w[i] = true
} else if (semiperfect(i, divs)) {
for (j in i until limit step i) w[j] = true
}
}
return w
}
fun main() {
val w = sieve(17000)
var count = 0
val max = 25
println("The first 25 weird numbers are:")
var n = 2
while (count < max) {
if (!w[n]) {
print("$n ")
count++
}
n += 2
}
println()
}

111
Task/Weird-numbers/Lua/weird-numbers.lua Normal file
View file

@ -0,0 +1,111 @@
function make(n, d)
local a = {}
for i=1,n do
table.insert(a, d)
end
return a
end
function reverse(t)
local n = #t
local i = 1
while i < n do
t[i],t[n] = t[n],t[i]
i = i + 1
n = n - 1
end
end
function tail(list)
return { select(2, unpack(list)) }
end
function divisors(n)
local divs = {}
table.insert(divs, 1)
local divs2 = {}
local i = 2
while i * i <= n do
if n % i == 0 then
local j = n / i
table.insert(divs, i)
if i ~= j then
table.insert(divs2, j)
end
end
i = i + 1
end
reverse(divs)
for i,v in pairs(divs) do
table.insert(divs2, v)
end
return divs2
end
function abundant(n, divs)
local sum = 0
for i,v in pairs(divs) do
sum = sum + v
end
return sum > n
end
function semiPerfect(n, divs)
if #divs > 0 then
local h = divs[1]
local t = tail(divs)
if n < h then
return semiPerfect(n, t)
else
return n == h
or semiPerfect(n - h, t)
or semiPerfect(n, t)
end
else
return false
end
end
function sieve(limit)
-- false denotes abundant and not semi-perfect.
-- Only interested in even numbers >= 2
local w = make(limit, false)
local i = 2
while i < limit do
if not w[i] then
local divs = divisors(i)
if not abundant(i, divs) then
w[i] = true
elseif semiPerfect(i, divs) then
local j = i
while j < limit do
w[j] = true
j = j + i
end
end
end
i = i + 1
end
return w
end
function main()
local w = sieve(17000)
local count = 0
local max = 25
print("The first 25 weird numbers:")
local n = 2
while count < max do
if not w[n] then
io.write(n, ' ')
count = count + 1
end
n = n + 2
end
print()
end
main()

30
Task/Weird-numbers/Mathematica/weird-numbers.math Normal file
View file

@ -0,0 +1,30 @@
ClearAll[WeirdNumberQ, HasSumQ]
HasSumQ[n_Integer, xs_List] := HasSumHelperQ[n, ReverseSort[xs]]
HasSumHelperQ[n_Integer, xs_List] := Module[{h, t},
If[Length[xs] > 0,
h = First[xs];
t = Drop[xs, 1];
If[n < h,
HasSumHelperQ[n, t]
,
n == h \[Or] HasSumHelperQ[n - h, t] \[Or] HasSumHelperQ[n, t]
]
,
False
]
]
WeirdNumberQ[n_Integer] := Module[{divs},
divs = Most[Divisors[n]];
If[Total[divs] > n,
! HasSumQ[n, divs]
,
False
]
]
r = {};
n = 0;
While[
Length[r] < 25,
If[WeirdNumberQ[++n], AppendTo[r, n]]
]
Print[r]

45
Task/Weird-numbers/Nim/weird-numbers.nim Normal file
View file

@ -0,0 +1,45 @@
import algorithm, math, strutils
func divisors(n: int): seq[int] =
var smallDivs = @[1]
for i in 2..sqrt(n.toFloat).int:
if n mod i == 0:
let j = n div i
smallDivs.add i
if i != j: result.add j
result.add reversed(smallDivs)
func abundant(n: int; divs: seq[int]): bool {.inline.}=
sum(divs) > n
func semiperfect(n: int; divs: seq[int]): bool =
if divs.len > 0:
let h = divs[0]
let t = divs[1..^1]
result = if n < h: semiperfect(n, t)
else: n == h or semiperfect(n - h, t) or semiperfect(n, t)
func sieve(limit: int): seq[bool] =
# False denotes abundant and not semi-perfect.
# Only interested in even numbers >= 2.
result.setLen(limit)
for i in countup(2, limit - 1, 2):
if result[i]: continue
let divs = divisors(i)
if not abundant(i, divs):
result[i] = true
elif semiperfect(i, divs):
for j in countup(i, limit - 1, i):
result[j] = true
const Max = 25
let w = sieve(17_000)
var list: seq[int]
echo "The first 25 weird numbers are:"
var n = 2
while list.len != Max:
if not w[n]: list.add n
inc n, 2
echo list.join(" ")

37
Task/Weird-numbers/Perl/weird-numbers-1.pl Normal file
View file

@ -0,0 +1,37 @@
use strict;
use feature 'say';
use List::Util 'sum';
use POSIX 'floor';
use Algorithm::Combinatorics 'subsets';
use ntheory <is_prime divisors>;
sub abundant {
my($x) = @_;
my $s = sum( my @l = is_prime($x) ? 1 : grep { $x != $_ } divisors($x) );
$s > $x ? ($s, sort { $b <=> $a } @l) : ();
}
my(@weird,$n);
while () {
$n++;
my ($sum, @div) = abundant($n);
next unless $sum; # Weird number must be abundant, skip it if it isn't.
next if $sum / $n > 1.1; # There aren't any weird numbers with a sum:number ratio greater than 1.08 or so.
if ($n >= 10430 and (! int $n%70) and is_prime(int $n/70)) {
# It's weird. All numbers of the form 70 * (a prime 149 or larger) are weird
} else {
my $next;
my $l = shift @div;
my $iter = subsets(\@div);
while (my $s = $iter->next) {
++$next and last if sum(@$s) == $n - $l;
}
next if $next;
}
push @weird, $n;
last if @weird == 25;
}
say "The first 25 weird numbers:\n" . join ' ', @weird;

34
Task/Weird-numbers/Perl/weird-numbers-2.pl Normal file
View file

@ -0,0 +1,34 @@
use 5.010;
use strict;
use ntheory qw(vecsum divisors divisor_sum);
sub is_pseudoperfect {
my ($n, $d, $s, $m) = @_;
$d //= do { my @d = divisors($n); pop(@d); \@d };
$s //= vecsum(@$d);
$m //= $#$d;
return 0 if $m < 0;
while ($d->[$m] > $n) {
$s -= $d->[$m--];
}
return 1 if ($n == $s or $d->[$m] == $n);
is_pseudoperfect($n-$d->[$m], $d, $s-$d->[$m], $m - 1) ||
is_pseudoperfect($n, $d, $s-$d->[$m], $m - 1);
}
sub is_weird {
my ($n) = @_;
divisor_sum($n) > 2*$n and not is_pseudoperfect($n);
}
my @weird;
for (my $k = 1 ; @weird < 25 ; ++$k) {
push(@weird, $k) if is_weird($k);
}
say "The first 25 weird numbers:\n@weird";

47
Task/Weird-numbers/Phix/weird-numbers.phix Normal file
View file

@ -0,0 +1,47 @@
(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">abundant</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">divs</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #000000;">divs</span><span style="color: #0000FF;">)</span> <span style="color: #0000FF;">></span> <span style="color: #000000;">n</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">semiperfect</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">divs</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">divs</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;">false</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">h</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">divs</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">];</span> <span style="color: #000000;">divs</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">divs</span><span style="color: #0000FF;">[</span><span style="color: #000000;">2</span><span style="color: #0000FF;">..$]</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">h</span>
<span style="color: #008080;">or</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">></span><span style="color: #000000;">h</span> <span style="color: #008080;">and</span> <span style="color: #000000;">semiperfect</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">-</span><span style="color: #000000;">h</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">divs</span><span style="color: #0000FF;">))</span>
<span style="color: #008080;">or</span> <span style="color: #000000;">semiperfect</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">divs</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">sieve</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">limit</span><span style="color: #0000FF;">)</span>
<span style="color: #000080;font-style:italic;">-- true denotes abundant and not semi-perfect.
-- only interested in even numbers &gt;= 2</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">wierd</span> <span style="color: #0000FF;">:=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #000000;">limit</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">6</span> <span style="color: #008080;">to</span> <span style="color: #000000;">limit</span> <span style="color: #008080;">by</span> <span style="color: #000000;">6</span> <span style="color: #008080;">do</span>
<span style="color: #000080;font-style:italic;">-- eliminate multiples of 3</span>
<span style="color: #000000;">wierd</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #000000;">limit</span> <span style="color: #008080;">by</span> <span style="color: #000000;">2</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">wierd</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">then</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">divs</span> <span style="color: #0000FF;">:=</span> <span style="color: #7060A8;">factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #008080;">not</span> <span style="color: #000000;">abundant</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">divs</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">wierd</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span>
<span style="color: #008080;">elsif</span> <span style="color: #000000;">semiperfect</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">divs</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">i</span> <span style="color: #008080;">to</span> <span style="color: #000000;">limit</span> <span style="color: #008080;">by</span> <span style="color: #000000;">i</span> <span style="color: #008080;">do</span> <span style="color: #000000;">wierd</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span> <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">wierd</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #000080;font-style:italic;">--constant MAX = 25, sieve_limit = 16313 </span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">MAX</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">50</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">sieve_limit</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">26533</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">wierd</span> <span style="color: #0000FF;">:=</span> <span style="color: #000000;">sieve</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sieve_limit</span><span style="color: #0000FF;">),</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #000000;">sieve_limit</span> <span style="color: #008080;">by</span> <span style="color: #000000;">2</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">wierd</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">i</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">MAX</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"weird numbers"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">))})</span>
<!--

243
Task/Weird-numbers/Python/weird-numbers.py Normal file
View file

@ -0,0 +1,243 @@
'''Weird numbers'''
from itertools import chain, count, islice, repeat
from functools import reduce
from math import sqrt
from time import time
# weirds :: Gen [Int]
def weirds():
'''Non-finite stream of weird numbers.
(Abundant, but not semi-perfect)
OEIS: A006037
'''
def go(n):
ds = descPropDivs(n)
d = sum(ds) - n
return [n] if 0 < d and not hasSum(d, ds) else []
return concatMap(go)(count(1))
# hasSum :: Int -> [Int] -> Bool
def hasSum(n, xs):
'''Does any subset of xs sum to n ?
(Assuming xs to be sorted in descending
order of magnitude)'''
def go(n, xs):
if xs:
h, t = xs[0], xs[1:]
if n < h: # Head too big. Forget it. Tail ?
return go(n, t)
else:
# The head IS the target ?
# Or the tail contains a sum for the
# DIFFERENCE between the head and the target ?
# Or the tail contains some OTHER sum for the target ?
return n == h or go(n - h, t) or go(n, t)
else:
return False
return go(n, xs)
# descPropDivs :: Int -> [Int]
def descPropDivs(n):
'''Descending positive divisors of n,
excluding n itself.'''
root = sqrt(n)
intRoot = int(root)
blnSqr = root == intRoot
lows = [x for x in range(1, 1 + intRoot) if 0 == n % x]
return [
n // x for x in (
lows[1:-1] if blnSqr else lows[1:]
)
] + list(reversed(lows))
# --------------------------TEST---------------------------
# main :: IO ()
def main():
'''Test'''
start = time()
n = 50
xs = take(n)(weirds())
print(
(tabulated('First ' + str(n) + ' weird numbers:\n')(
lambda i: str(1 + i)
)(str)(5)(
index(xs)
)(range(0, n)))
)
print(
'\nApprox computation time: ' +
str(int(1000 * (time() - start))) + ' ms'
)
# -------------------------GENERIC-------------------------
# chunksOf :: Int -> [a] -> [[a]]
def chunksOf(n):
'''A series of lists of length n,
subdividing the contents of xs.
Where the length of xs is not evenly divible,
the final list will be shorter than n.'''
return lambda xs: reduce(
lambda a, i: a + [xs[i:n + i]],
range(0, len(xs), n), []
) if 0 < n else []
# compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
def compose(g):
'''Right to left function composition.'''
return lambda f: lambda x: g(f(x))
# concatMap :: (a -> [b]) -> [a] -> [b]
def concatMap(f):
'''A concatenated list or string over which a function f
has been mapped.
The list monad can be derived by using an (a -> [b])
function which wraps its output in a list (using an
empty list to represent computational failure).
'''
return lambda xs: chain.from_iterable(map(f, xs))
# index (!!) :: [a] -> Int -> a
def index(xs):
'''Item at given (zero-based) index.'''
return lambda n: None if 0 > n else (
xs[n] if (
hasattr(xs, "__getitem__")
) else next(islice(xs, n, None))
)
# paddedMatrix :: a -> [[a]] -> [[a]]
def paddedMatrix(v):
''''A list of rows padded to equal length
(where needed) with instances of the value v.'''
def go(rows):
return paddedRows(
len(max(rows, key=len))
)(v)(rows)
return lambda rows: go(rows) if rows else []
# paddedRows :: Int -> a -> [[a]] -[[a]]
def paddedRows(n):
'''A list of rows padded (but never truncated)
to length n with copies of value v.'''
def go(v, xs):
def pad(x):
d = n - len(x)
return (x + list(repeat(v, d))) if 0 < d else x
return list(map(pad, xs))
return lambda v: lambda xs: go(v, xs) if xs else []
# showColumns :: Int -> [String] -> String
def showColumns(n):
'''A column-wrapped string
derived from a list of rows.'''
def go(xs):
def fit(col):
w = len(max(col, key=len))
def pad(x):
return x.ljust(4 + w, ' ')
return ''.join(map(pad, col))
q, r = divmod(len(xs), n)
return unlines(map(
fit,
transpose(paddedMatrix('')(
chunksOf(q + int(bool(r)))(
xs
)
))
))
return lambda xs: go(xs)
# succ :: Enum a => a -> a
def succ(x):
'''The successor of a value. For numeric types, (1 +).'''
return 1 + x if isinstance(x, int) else (
chr(1 + ord(x))
)
# tabulated :: String -> (a -> String) ->
# (b -> String) ->
# Int ->
# (a -> b) -> [a] -> String
def tabulated(s):
'''Heading -> x display function -> fx display function ->
number of columns -> f -> value list -> tabular string.'''
def go(xShow, fxShow, intCols, f, xs):
w = max(map(compose(len)(xShow), xs))
return s + '\n' + showColumns(intCols)([
xShow(x).rjust(w, ' ') + ' -> ' + fxShow(f(x)) for x in xs
])
return lambda xShow: lambda fxShow: lambda nCols: (
lambda f: lambda xs: go(
xShow, fxShow, nCols, f, xs
)
)
# take :: Int -> [a] -> [a]
# take :: Int -> String -> String
def take(n):
'''The prefix of xs of length n,
or xs itself if n > length xs.'''
return lambda xs: (
xs[0:n]
if isinstance(xs, list)
else list(islice(xs, n))
)
# transpose :: Matrix a -> Matrix a
def transpose(m):
'''The rows and columns of the argument transposed.
(The matrix containers and rows can be lists or tuples).'''
if m:
inner = type(m[0])
z = zip(*m)
return (type(m))(
map(inner, z) if tuple != inner else z
)
else:
return m
# unlines :: [String] -> String
def unlines(xs):
'''A single string derived by the intercalation
of a list of strings with the newline character.'''
return '\n'.join(xs)
# until :: (a -> Bool) -> (a -> a) -> a -> a
def until(p):
'''The result of repeatedly applying f until p holds.
The initial seed value is x.'''
def go(f, x):
v = x
while not p(v):
v = f(v)
return v
return lambda f: lambda x: go(f, x)
# MAIN ----------------------------------------------------
if __name__ == '__main__':
main()

42
Task/Weird-numbers/Quackery/weird-numbers.quackery Normal file
View file

@ -0,0 +1,42 @@
[ stack ] is target ( --> s )
[ stack ] is success ( --> s )
[ stack ] is makeable ( --> s )
[ bit makeable take
2dup & 0 !=
dip [ | makeable put ] ] is made ( n --> b )
[ ' [ 0 ] swap
dup target put
properdivisors
0 over witheach +
target share > not iff
[ target release
2drop false ] done
true success put
0 makeable put
witheach
[ over witheach
[ over dip
[ +
dup target share = iff
[ false success replace
drop conclude ] done
dup target share < iff
[ dup made not iff
join else drop ]
else drop ] ]
success share not if conclude
drop ]
drop
target release
makeable release
success take ] is weird ( n --> b )
[] 0
[ 1+
dup weird if
[ tuck join swap ]
over size 25 = until ]
drop
echo

70
Task/Weird-numbers/REXX/weird-numbers-1.rexx Normal file
View file

@ -0,0 +1,70 @@
/*REXX program finds and displays N weird numbers in a vertical format (with index).*/
parse arg n cols . /*obtain optional arguments from the CL*/
if n=='' | n=="," then n= 25 /*Not specified? Then use the default.*/
if cols=='' | cols=="," then cols= 10 /* " " " " " " */
w= 10 /*width of a number in any column. */
if cols>0 then say ' index │'center(' weird numbers', 1 + cols*(w+1) )
if cols>0 then say '───────┼'center("" , 1 + cols*(w+1), '─')
idx= 1; $= /*index for the output list; $: 1 line*/
weirds= 0 /*the count of weird numbers (so far).*/
do j=2 by 2 until weirds==n /*examine even integers 'til have 'nuff*/
if \weird(j) then iterate /*Not a weird number? Then skip it. */
weirds= weirds + 1 /*bump the count of weird numbers. */
c= commas(j) /*maybe add commas to the number. */
$= $ right(c, max(w, length(c) ) ) /*add a nice prime ──► list, allow big#*/
if weirds//cols\==0 then iterate /*have we populated a line of output? */
say center(idx, 7)'│' substr($, 2); $= /*display what we have so far (cols). */
idx= idx + cols /*bump the index count for the output*/
end /*j*/
if $\=='' then say center(idx, 7)"│" substr($, 2) /*possible display residual output.*/
if cols>0 then say '───────┴'center("" , 1 + cols*(w+1), '─')
say
say 'Found ' commas(weirds) ' weird numbers'
exit 0 /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
commas: parse arg _; do ic=length(_)-3 to 1 by -3; _=insert(',', _, ic); end; return _
/*──────────────────────────────────────────────────────────────────────────────────────*/
DaS: procedure; parse arg x 1 z 1,b; a= 1 /*get X,Z,B (the 1st arg); init A list.*/
r= 0; q= 1 /* [↓] ══integer square root══ ___ */
do while q<=z; q=q*4; end /*R: an integer which will be √ X */
do while q>1; q=q%4; _= z-r-q; r=r%2; if _>=0 then do; z=_; r=r+q; end
end /*while q>1*/ /* [↑] compute the integer sqrt of X.*/
sig= a /*initialize the sigma so far. ___ */
do j=2 to r - (r*r==x) /*divide by some integers up to √ X */
if x//j==0 then do; a=a j; b= x%j b /*if ÷, add both divisors to α and ß. */
sig= sig +j +x%j /*bump the sigma (the sum of divisors).*/
end
end /*j*/ /* [↑] % is the REXX integer division*/
/* [↓] adjust for a square. ___*/
if j*j==x then return sig+j a j b /*Was X a square? If so, add √ X */
return sig a b /*return the divisors (both lists). */
/*──────────────────────────────────────────────────────────────────────────────────────*/
weird: procedure; parse arg x . /*obtain a # to be tested for weirdness*/
if x<70 | x//3==0 then return 0 /*test if X is too low or multiple of 3*/
parse value DaS(x) with sigma divs /*obtain sigma and the proper divisors.*/
if sigma<=x then return 0 /*X isn't abundant (sigma too small).*/
#= words(divs) /*count the number of divisors for X. */
if #<3 then return 0 /*Not enough divisors? " " */
if #>15 then return 0 /*number of divs > 15? It's not weird.*/
a.= /*initialize the A. stemmed array.*/
do i=1 for #; _= word(divs, i) /*obtain one of the divisors of X. */
@.i= _; a._= . /*assign proper divs──►@ array; also id*/
end /*i*/
df= sigma - x /*calculate difference between Σ and X.*/
if a.df==. then return 0 /*Any divisor is equal to DF? Not weird*/
c= 0 /*zero combo counter; calc. power of 2.*/
do p=1 for 2**#-2; c= c + 1 /*convert P──►binary with leading zeros*/
yy.c= strip( x2b( d2x(p) ), 'L', 0) /*store this particular combination. */
end /*p*/
/* [↓] decreasing partitions is faster*/
do part=c by -1 for c; s= 0 /*test of a partition add to the arg X.*/
_= yy.part; L= length(_) /*obtain one method of partitioning. */
do cp=L by -1 for L /*obtain a sum of a partition. */
if substr(_,cp,1) then do; s= s + @.cp /*1 bit? Then add ──►S*/
if s==x then return 0 /*Sum equal? Not weird*/
if s==df then return 0 /*Sum = DF? " " */
if s>x then iterate /*Sum too big? Try next*/
end
end /*cp*/
end /*part*/; return 1 /*no sum equal to X, so X is weird.*/

90
Task/Weird-numbers/REXX/weird-numbers-2.rexx Normal file
View file

@ -0,0 +1,90 @@
/*REXX program finds and displays N weird numbers in a vertical format (with index).*/
parse arg n cols . /*obtain optional arguments from the CL*/
if n=='' | n=="," then n= 400 /*Not specified? Then use the default.*/
if cols=='' | cols=="," then cols= 10 /* " " " " " " */
w= 10 /*width of a number in any column. */
call genP /*generate primes just past Hp. */
if cols>0 then say ' index │'center(' weird numbers', 1 + cols*(w+1) )
if cols>0 then say '───────┼'center("" , 1 + cols*(w+1), '─')
weirds= 0; !!.= 0 /*the count of weird numbers (so far).*/
idx= 1; $= /*index for the output list; $: 1 line*/
do j=2 by 2 until weirds==n /*examine even integers 'til have 'nuff*/
if \weird(j) then iterate /*Not a weird number? Then skip it. */
weirds= weirds + 1 /*bump the count of weird numbers. */
do a=1 for # until _>hp; if @.a<sigma+j then iterate; _= j*@.a; !!._= 1
end /*a*/
c= commas(j) /*maybe add commas to the number. */
$= $ right(c, max(w, length(c) ) ) /*add a nice prime ──► list, allow big#*/
if weirds//cols\==0 then iterate /*have we populated a line of output? */
say center(idx, 7)'│' substr($, 2); $= /*display what we have so far (cols). */
idx= idx + cols /*bump the index count for the output*/
end /*j*/
if $\=='' then say center(idx, 7)"│" substr($, 2) /*possible display residual output.*/
if cols>0 then say '───────┴'center("" , 1 + cols*(w+1), '─')
say
say 'Found ' commas(weirds) ' weird numbers'
exit 0 /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
commas: parse arg _; do ic=length(_)-3 to 1 by -3; _=insert(',', _, ic); end; return _
/*──────────────────────────────────────────────────────────────────────────────────────*/
DaS: procedure; parse arg x 1 z 1,b; a= 1 /*get X,Z,B (the 1st arg); init A list.*/
r= 0; q= 1 /* [↓] ══integer square root══ ___ */
do while q<=z; q=q*4; end /*R: an integer which will be √ X */
do while q>1; q=q%4; _= z-r-q; r=r%2; if _>=0 then do; z=_; r=r+q; end
end /*while q>1*/ /* [↑] compute the integer sqrt of X.*/
sig = a /*initialize the sigma so far. ___ */
do j=2 to r - (r*r==x) /*divide by some integers up to √ X */
if x//j==0 then do; a=a j; b= x%j b /*if ÷, add both divisors to α & ß. */
sig= sig +j +x%j /*bump the sigma (the sum of Pdivisors)*/
end
end /*j*/ /* [↑] % is the REXX integer division*/
/* [↓] adjust for a square. ___*/
if j*j==x then return sig+j a j b /*Was X a square? If so, add √ X */
return sig a b /*return the divisors (both lists). */
/*──────────────────────────────────────────────────────────────────────────────────────*/
genP: hp= 1000 * n /*high Prime limit; define 2 low primes*/
@.1=2; @.2=3; @.3=5; @.4=7; @.5=11 /*define some low primes. */
#=5; s.#= @.# **2 /*number of primes so far; prime². */
/* [↓] generate more primes ≤ high.*/
do j=@.#+2 by 2 for max(0, hp%2-@.#%2-1) /*find odd primes from here on. */
parse var j '' -1 _; if _==5 then iterate /*J divisible by 5? (right dig)*/
if j// 3==0 then iterate /*" " " 3? */
if j// 7==0 then iterate /*" " " 7? */
/* [↑] the above five lines saves time*/
do k=5 while s.k<=j /* [↓] divide by the known odd primes.*/
if j // @.k == 0 then iterate j /*Is J ÷ X? Then not prime. ___ */
end /*k*/ /* [↑] only process numbers ≤ √ J */
#= #+1; @.#= j; s.#= j*j /*bump # of Ps; assign next P; P²; P# */
end /*j*/; return
/*──────────────────────────────────────────────────────────────────────────────────────*/
weird: procedure expose !!. sigma; parse arg x /*obtain a # to be tested for weirdness*/
if x<70 | x//3==0 then return 0 /*test if X is too low or multiple of 3*/
if !!.x then return 1 /*Is this a prime*previous #? Found one*/
parse value DaS(x) with sigma divs /*obtain sigma and the proper divisors.*/
if sigma<=x then return 0 /*X isn't abundant (sigma too small).*/
#= words(divs) /*count the number of divisors for X. */
if #<3 then return 0 /*Not enough divisors? " " */
if #>15 then return 0 /*number of divs > 15? It's not weird.*/
a.= /*initialize the A. stemmed array.*/
do i=1 for #; _= word(divs, i) /*obtain one of the divisors of X. */
@.i= _; a._= . /*assign proper divs──►@ array; also id*/
end /*i*/
df= sigma - x /*calculate difference between Σ and X.*/
if a.df==. then return 0 /*Any divisor is equal to DF? Not weird*/
c= 0; u= 2**# /*zero combo counter; calc. power of 2.*/
do p=1 for u-2; c= c + 1 /*convert P──►binary with leading zeros*/
yy.c= strip( x2b( d2x(p) ), 'L', 0) /*store this particular combination. */
end /*p*/
/* [↓] decreasing partitions is faster*/
do part=c by -1 for c; s= 0 /*test of a partition add to the arg X.*/
_= yy.part; L= length(_) /*obtain one method of partitioning. */
do cp=L by -1 for L /*obtain a sum of a partition. */
if substr(_,cp,1) then do; s= s + @.cp /*1 bit? Then add ──►S*/
if s==x then return 0 /*Sum equal? Not weird*/
if s==df then return 0 /*Sum = DF? " " */
if s>x then iterate /*Sum too big? Try next*/
end
end /*cp*/
end /*part*/
return 1 /*no sum equal to X, so X is weird.*/

29
Task/Weird-numbers/Racket/weird-numbers.rkt Normal file
View file

@ -0,0 +1,29 @@
#lang racket
(require math/number-theory)
(define (abundant? n proper-divisors)
(> (apply + proper-divisors) n))
(define (semi-perfect? n proper-divisors)
(let recur ((ds proper-divisors) (n n))
(or (zero? n)
(and (positive? n)
(pair? ds)
(or (recur (cdr ds) n)
(recur (cdr ds) (- n (car ds))))))))
(define (weird? n)
(let ((proper-divisors (drop-right (divisors n) 1))) ;; divisors includes n
(and (abundant? n proper-divisors) (not (semi-perfect? n proper-divisors)))))
(module+ main
(let recur ((i 0) (n 1) (acc null))
(cond [(= i 25) (reverse acc)]
[(weird? n) (recur (add1 i) (add1 n) (cons n acc))]
[else (recur i (add1 n) acc)])))
(module+ test
(require rackunit)
(check-true (weird? 70))
(check-false (weird? 12)))

26
Task/Weird-numbers/Raku/weird-numbers.raku Normal file
View file

@ -0,0 +1,26 @@
sub abundant (\x) {
my @l = x.is-prime ?? 1 !! flat
1, (2 .. x.sqrt.floor).map: -> \d {
my \y = x div d;
next if y * d !== x;
d !== y ?? (d, y) !! d
};
(my $s = @l.sum) > x ?? ($s, |@l.sort(-*)) !! ();
}
my @weird = (2, 4, {|($_ + 4, $_ + 6)} ... *).map: -> $n {
my ($sum, @div) = $n.&abundant;
next unless $sum; # Weird number must be abundant, skip it if it isn't.
next if $sum / $n > 1.1; # There aren't any weird numbers with a sum:number ratio greater than 1.08 or so.
if $n >= 10430 and ($n %% 70) and ($n div 70).is-prime {
# It's weird. All numbers of the form 70 * (a prime 149 or larger) are weird
} else {
my $next;
my $l = @div.shift;
++$next and last if $_.sum == $n - $l for @div.combinations;
next if $next;
}
$n
}
put "The first 25 weird numbers:\n", @weird[^25];

77
Task/Weird-numbers/Ruby/weird-numbers.rb Normal file
View file

@ -0,0 +1,77 @@
def divisors(n)
divs = [1]
divs2 = []
i = 2
while i * i <= n
if n % i == 0 then
j = (n / i).to_i
divs.append(i)
if i != j then
divs2.append(j)
end
end
i = i + 1
end
divs2 += divs.reverse
return divs2
end
def abundant(n, divs)
return divs.sum > n
end
def semiperfect(n, divs)
if divs.length > 0 then
h = divs[0]
t = divs[1..-1]
if n < h then
return semiperfect(n, t)
else
return n == h || semiperfect(n - h, t) || semiperfect(n, t)
end
else
return false
end
end
def sieve(limit)
w = Array.new(limit, false)
i = 2
while i < limit
if not w[i] then
divs = divisors(i)
if not abundant(i, divs) then
w[i] = true
elsif semiperfect(i, divs) then
j = i
while j < limit
w[j] = true
j = j + i
end
end
end
i = i + 2
end
return w
end
def main
w = sieve(17000)
count = 0
max = 25
print "The first %d weird numbers:\n" % [max]
n = 2
while count < max
if not w[n] then
print n, " "
count = count + 1
end
n = n + 2
end
print "\n"
end
main()

20
Task/Weird-numbers/Sidef/weird-numbers.sidef Normal file
View file

@ -0,0 +1,20 @@
func is_pseudoperfect(n, d = n.divisors.slice(0, -2), s = d.sum, m = d.end) {
return false if (m < 0)
while (d[m] > n) {
s -= d[m--]
}
return true if (n == s)
return true if (d[m] == n)
__FUNC__(n-d[m], d, s-d[m], m-1) || __FUNC__(n, d, s-d[m], m-1)
}
func is_weird(n) {
(n.sigma > 2*n) && !is_pseudoperfect(n)
}
var w = (1..Inf -> lazy.grep(is_weird).first(25))
say "The first 25 weird numbers:\n#{w.join(' ')}"

74
Task/Weird-numbers/V-(Vlang)/weird-numbers.v Normal file
View file

@ -0,0 +1,74 @@
fn divisors(n int) []int {
mut divs := [1]
mut divs2 := []int{}
for i := 2; i*i <= n; i++ {
if n%i == 0 {
j := n / i
divs << i
if i != j {
divs2 << j
}
}
}
for i := divs.len - 1; i >= 0; i-- {
divs2 << divs[i]
}
return divs2
}
fn abundant(n int, divs []int) bool {
mut sum := 0
for div in divs {
sum += div
}
return sum > n
}
fn semiperfect(n int, divs []int) bool {
le := divs.len
if le > 0 {
h := divs[0]
t := divs[1..]
if n < h {
return semiperfect(n, t)
} else {
return n == h || semiperfect(n-h, t) || semiperfect(n, t)
}
} else {
return false
}
}
fn sieve(limit int) []bool {
// false denotes abundant and not semi-perfect.
// Only interested in even numbers >= 2
mut w := []bool{len: limit}
for i := 2; i < limit; i += 2 {
if w[i] {
continue
}
divs := divisors(i)
if !abundant(i, divs) {
w[i] = true
} else if semiperfect(i, divs) {
for j := i; j < limit; j += i {
w[j] = true
}
}
}
return w
}
fn main() {
w := sieve(17000)
mut count := 0
max := 25
println("The first 25 weird numbers are:")
for n := 2; count < max; n += 2 {
if !w[n] {
print("$n ")
count++
}
}
println('')
}

86
Task/Weird-numbers/Visual-Basic-.NET/weird-numbers.vb Normal file
View file

@ -0,0 +1,86 @@
Module Module1
Dim resu As New List(Of Integer)
Function TestAbundant(n As Integer, ByRef divs As List(Of Integer)) As Boolean
divs = New List(Of Integer)
Dim sum As Integer = -n : For i As Integer = Math.Sqrt(n) To 1 Step -1
If n Mod i = 0 Then divs.Add(i) : Dim j As Integer = n / i : divs.Insert(0, j) : sum += i + j
Next : divs(0) = sum - divs(0) : Return divs(0) > 0
End Function
Function subList(src As List(Of Integer), Optional first As Integer = Integer.MinValue) As List(Of Integer)
subList = src.ToList : subList.RemoveAt(1)
End Function
Function semiperfect(divs As List(Of Integer)) As Boolean
If divs.Count < 2 Then Return False
Select Case divs.First.CompareTo(divs(1))
Case 0 : Return True
Case -1 : Return semiperfect(subList(divs))
Case 1 : Dim t As List(Of Integer) = subList(divs) : t(0) -= divs(1)
If semiperfect(t) Then Return True Else t(0) = divs.First : Return semiperfect(t)
End Select : Return False ' execution can't get here, just for compiler warning
End Function
Function Since(et As TimeSpan) As String ' big ugly routine to prettify the elasped time
If et > New TimeSpan(2000000) Then
Dim s As String = " " & et.ToString(), p As Integer = s.IndexOf(":"), q As Integer = s.IndexOf(".")
If q < p Then s = s.Insert(q, "Days") : s = s.Replace("Days.", "Days, ")
p = s.IndexOf(":") : s = s.Insert(p, "h") : s = s.Replace("h:", "h ")
p = s.IndexOf(":") : s = s.Insert(p, "m") : s = s.Replace("m:", "m ")
s = s.Replace(" 0", " ").Replace(" 0h", " ").Replace(" 0m", " ") & "s"
Return s.TrimStart()
Else
If et > New TimeSpan(1500) Then
Return et.TotalMilliseconds.ToString() & "ms"
Else
If et > New TimeSpan(15) Then
Return (et.TotalMilliseconds * 1000.0).ToString() & "µs"
Else
Return (et.TotalMilliseconds * 1000000.0).ToString() & "ns"
End If
End If
End If
End Function
Sub Main(args As String())
Dim sw As New Stopwatch, st As Integer = 2, stp As Integer = 1020, count As Integer = 0
Dim max As Integer = 25, halted As Boolean = False
If args.Length > 0 Then _
Dim t As Integer = Integer.MaxValue : If Integer.TryParse(args(0), t) Then max = If(t > 0, t, Integer.MaxValue)
If max = Integer.MaxValue Then
Console.WriteLine("Calculating weird numbers, press a key to halt.")
stp *= 10
Else
Console.WriteLine("The first {0} weird numbers:", max)
End If
If max < 25 Then stp = 140
sw.Start()
Do : Parallel.ForEach(Enumerable.Range(st, stp),
Sub(n)
Dim divs As List(Of Integer) = Nothing
If TestAbundant(n, divs) AndAlso Not semiperfect(divs) Then
SyncLock resu : resu.Add(n) : End SyncLock
End If
End Sub)
If resu.Count > 0 Then
resu.Sort()
If count + resu.Count > max Then
resu = resu.Take(max - count).ToList
End If
Console.Write(String.Join(" ", resu) & " ")
count += resu.Count : resu.Clear()
End If
If Console.KeyAvailable Then Console.ReadKey() : halted = True : Exit Do
st += stp
Loop Until count >= max
sw.Stop()
If max < Integer.MaxValue Then
Console.WriteLine(vbLf & "Computation time was {0}.", Since(sw.Elapsed))
If halted Then Console.WriteLine("Halted at number {0}.", count)
Else
Console.WriteLine(vbLf & "Computation time was {0} for the first {1} weird numbers.", Since(sw.Elapsed), count)
End If
End Sub
End Module

50
Task/Weird-numbers/Wren/weird-numbers.wren Normal file
View file

@ -0,0 +1,50 @@
import "/math" for Int, Nums
import "/iterate" for Stepped
var semiperfect // recursive
semiperfect = Fn.new { |n, divs|
var le = divs.count
if (le == 0) return false
var h = divs[0]
if (n == h) return true
if (le == 1) return false
var t = divs[1..-1]
if (n < h) return semiperfect.call(n, t)
return semiperfect.call(n-h, t) || semiperfect.call(n, t)
}
var sieve = Fn.new { |limit|
// 'false' denotes abundant and not semi-perfect.
// Only interested in even numbers >= 2
var w = List.filled(limit, false)
for (j in Stepped.new(6...limit, 6)) w[j] = true // eliminate multiples of 3
for (i in Stepped.new(2...limit, 2)) {
if (!w[i]) {
var divs = Int.properDivisors(i)
var sum = Nums.sum(divs)
if (sum <= i) {
w[i] = true
} else if (semiperfect.call(sum-i, divs)) {
for (j in Stepped.new(i...limit, i)) w[j] = true
}
}
}
return w
}
var start = System.clock
var limit = 16313
var w = sieve.call(limit)
var count = 0
var max = 25
System.print("The first 25 weird numbers are:")
var n = 2
while (count < max) {
if (!w[n]) {
System.write("%(n) ")
count = count + 1
}
n = n + 2
}
System.print()
System.print("\nTook %(((System.clock-start)*1000).round) milliseconds")

99
Task/Weird-numbers/XPL0/weird-numbers.xpl0 Normal file
View file

@ -0,0 +1,99 @@
def SizeOfInt = 4;
def \IntA\ Ptr, Size;
int Array(2);
func Divisors(N); \Returns a list of proper divisors for N
int N;
int Divs, Divs2, Out;
int I, J, C1, C2;
[C1:= 0; C2:= 0;
Divs:= MAlloc(N * SizeOfInt / 2);
Divs2:= MAlloc(N * SizeOfInt / 2);
Divs(C1):= 1; C1:= C1+1;
I:= 2;
while I*I <= N do
[if rem(N/I) = 0 then
[J:= N/I;
Divs(C1):= I; C1:= C1+1;
if I # J then
[Divs2(C2):= J; C2:= C2+1];
];
I:= I+1;
];
Out:= MAlloc((C1+C2) * SizeOfInt);
for I:= 0 to C2-1 do
Out(I):= Divs2(I);
for I:= 0 to C1-1 do
Out(C2+I):= Divs(C1-I-1);
Array(Ptr):= Out;
Array(Size):= C1 + C2;
Release(Divs);
Release(Divs2);
return Array;
];
func Abundant(N, Divs); \Returns 'true' if N is abundant
int N, Divs;
int Sum, I;
[Sum:= 0;
for I:= 0 to Divs(Size)-1 do
Sum:= Sum + Divs(Ptr,I);
return Sum > N;
];
func Semiperfect(N, Divs); \Returns 'true' if N is semiperfect
int N, Divs;
int H, T, TA(2);
[if Divs(Size) > 0 then
[H:= Divs(Ptr,0);
T:= Divs(Ptr)+SizeOfInt;
TA(Ptr):= T;
TA(Size):= Divs(Size)-1;
if N < H then
return Semiperfect(N, TA)
else return N = H or Semiperfect(N-H, TA) or Semiperfect(N, TA);
]
else return false;
];
func Sieve(Limit); \Return array of weird number indexes set 'false'
int Limit; \i.e. non-abundant and non-semiperfect
int W, Divs(2), I, J;
[W:= MAlloc(Limit * SizeOfInt);
for I:= 0 to Limit-1 do W(I):= 0; \for safety
I:= 2;
while I < Limit do
[if W(I) = 0 then
[Divs:= Divisors(I);
if not Abundant(I, Divs) then
W(I):= true
else if Semiperfect(I, Divs) then
[J:= I;
while J < Limit do
[W(J):= true;
J:= J+I;
];
];
];
I:= I+2;
];
Release(Divs(Ptr));
return W;
];
int W, Count, Max, N;
[W:= Sieve(17000);
Count:= 0;
Max:= 25;
Text(0, "The first 25 weird numbers:^m^j");
N:= 2;
while Count < Max do
[if not W(N) then
[IntOut(0, N); ChOut(0, ^ );
Count:= Count+1;
];
N:= N+2;
];
CrLf(0);
Release(W);
]

27
Task/Weird-numbers/Zkl/weird-numbers-1.zkl Normal file
View file

@ -0,0 +1,27 @@
fcn properDivs(n){
if(n==1) return(T);
( pd:=[1..(n).toFloat().sqrt()].filter('wrap(x){ n%x==0 }) )
.pump(pd,'wrap(pd){ if(pd!=1 and (y:=n/pd)!=pd ) y else Void.Skip })
}
fcn abundant(n,divs){ divs.sum(0) > n }
fcn semiperfect(n,divs){
if(divs){
h,t := divs[0], divs[1,*];
if(n<h) return(semiperfect(n,t));
return((n==h) or semiperfect(n - h, t) or semiperfect(n, t));
}
False
}
fcn sieve(limit){
// False denotes abundant and not semi-perfect.
// Only interested in even numbers >= 2
w:=List.createLong(limit,False);
foreach i in ([2..limit - 1, 2]){
if(w[i]) continue;
divs:=properDivs(i);
if(not abundant(i,divs)) w[i]=True;
else if(semiperfect(i,divs))
{ foreach j in ([i..limit - 1, i]){ w[j]=True; } }
}
w
}

7
Task/Weird-numbers/Zkl/weird-numbers-2.zkl Normal file
View file

@ -0,0 +1,7 @@
w,count,max := sieve(17_000), 0, 25;
println("The first 25 weird numbers are:");
foreach n in ([2..* ,2]){
if(not w[n]){ print("%d ".fmt(n)); count+=1; }
if(count>=max) break;
}
println();