Aliquot sequence classifications: Difference between revisions

{{trans|Python}}

 

R sum((1 .. (n + 1) I/ 2).filter(x -> @n % x == 0 & @n != x))

 

L(n) [11, 12, 28, 496, 220, 1184, 12496, 1264460, 790, 909, 562, 1064, 1488]

V (cls, seq) = aliquot(n)

 

{{out}}

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

{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}

/* ARM assembly AARCH64 Raspberry PI 3B or android 64 bits */

/* program aliquotSeq64.s */

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

.include "../includeARM64.inc"

<pre>

Program 64 bits start

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

Assumes LONG INT is at least 64 bits, as in Algol 68G.

# aliquot sequence classification #

# maximum sequence length we consider #

print( ( newline ) )

OD

{{out}}

<pre>

=={{header|AppleScript}}==

 

if (n < 2) then return 0

set sum to 1

set output to output as text

set AppleScript's text item delimiters to astid

 

{{output}}

1: terminating 1, 0

2: terminating 2, 1, 0

1064: cyclic 1064, 1336, 1184, 1210

1488: non-terminating 1488, 2480, 3472, 4464, 8432, 9424, 10416, 21328, 22320, 55056, 95728, 96720, 236592, 459792, 881392, 882384

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

{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}

/* ARM assembly Raspberry PI */

/* program aliquotSeq.s */

.include "../affichage.inc"

 

<pre>

Program start

=={{header|AWK}}==

 

#!/bin/gawk -f

function sumprop(num, i,sum,root) {

}

 

{{out}}

<pre>

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

# by Jjuanhdez, 06/2022

 

next element

if clase = 0 then print " non-terminating"

 

=={{header|C}}==

===Brute Force===

The following implementation is a brute force method which takes a very, very long time for 15355717786080. To be fair to C, that's also true for many of the other implementations on this page which also implement the brute force method. See the next implementation for the best solution.

#include<stdlib.h>

#include<string.h>

return 0;

}

Input file, you can include 15355717786080 or similar numbers in this list but be prepared to wait for a very, very long time.:

<pre>

===Number Theoretic===

The following implementation, based on Number Theory, is the best solution for such a problem. All cases are handled, including 15355717786080, with all the numbers being processed and the output written to console practically instantaneously. The above brute force implementation is the original one and it remains to serve as a comparison of the phenomenal difference the right approach can make to a problem.

#include<string.h>

#include<stdlib.h>

return 0;

}

Input file, to emphasize the effectiveness of this approach, the last number in the file is 153557177860800, 10 times the special case mentioned in the task.

<pre>

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

This one follows the trail blazed by the "Number Theoretic" C example above.

#include <iostream>

#include <string>

classify_aliquot_sequence(153557177860800);

return 0;

 

{{out}}

=={{header|CLU}}==

{{trans|C++}}

 

% Remove leading and trailing whitespace (bigint$unparse adds a lot)

classify_aliquot_sequence(bigint$parse("15355717786080"))

classify_aliquot_sequence(bigint$parse("153557177860800"))

{{out}}

<pre>1: terminating, sequence: 1 0

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

Uses the Lisp function '''proper-divisors-recursive''' from [[Proper_divisors#Common_Lisp|Task:Proper Divisors]].

(defparameter *klimit* (expt 2 47))

(defparameter *asht* (make-hash-table))

(aliquot (+ k 1)))

(dolist (k '(11 12 28 496 220 1184 12496 1264460 790 909 562 1064 1488 15355717786080))

{{out}}

<pre>CL-USER(45): (main)

=={{header|D}}==

{{trans|Python}}

 

auto properDivisors(in ulong n) pure nothrow @safe /*@nogc*/ {

790, 909, 562, 1064, 1488])

writefln("%s: %s", n.aliquot[]);

{{out}}

<pre>Terminating: [1, 0]

 

=={{header|EchoLisp}}==

;; implementation of Floyd algorithm to find cycles in a graph

;; see Wikipedia https://en.wikipedia.org/wiki/Cycle_detection

(when (= x0 starter) (set! end starter)))

(writeln ...))

{{out}}

(lib 'math)

(lib 'bigint)

1000 terminating

1000 1340 1516 1144 1376 1396 1054 674 340 416 466 236 184 176 196 203 37 1 0 0 ...

 

=={{header|Elixir}}==

{{trans|Ruby}}

def divisors(1), do: []

def divisors(n), do: [1 | divisors(2,n,:math.sqrt(n))] |> Enum.sort

if n<10000000, do: :io.fwrite("~7w:~21s: ~p~n", [n, msg, s]),

else: :io.fwrite("~w: ~s: ~p~n", [n, msg, s])

 

{{out}}

=={{header|Factor}}==

For convenience, the term that caused termination is always included in the output sequence.

literals locals math math.functions math.primes.factors

math.ranges namespaces pair-rocket sequences sets ;

10 [1,b] test-cases append [ .classify ] each ;

 

{{out}}

<pre>

A more flexible syntax (such as Algol's) would enable the double scan of the TRAIL array to be avoided, as in if TRAIL[I:=MinLoc(Abs(TRAIL(1:L) - SF))] = SF then... That is, find the first index of array TRAIL such that ABS(TRAIL(1:L) - SF) is minimal, save that index in I, then access that element of TRAIL and test if it is equal to SF. The INDEX function could be use to find the first match, except that it is defined only for character variables. Alternatively, use an explicit DO-loop to search for equality, thus not employing fancy syntax, and not having to wonder if the ANY function will stop on the first match rather than wastefully continue the testing for all array elements. The modern style in manual writing is to employ vaguely general talk about arrays and omit specific details.

 

MODULE FACTORSTUFF !This protocol evades the need for multiple parameters, or COMMON, or one shapeless main line...

Concocted by R.N.McLean, MMXV.

END DO

END !Done.

 

=={{header|FreeBASIC}}==

{{trans|C}}

dim as ulongint result = 1, i

for i = 1 to power

for n as ubyte = 0 to 22

aliquotClassifier(nums(n))

 

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

seq, aliquot := classifySequence(k)

fmt.Printf("%d: %-15s %s\n", k, aliquot, joinWithCommas(seq))

 

{{out}}

 

=={{header|Haskell}}==

divisors n = filter ((0 ==) . (n `mod`)) [1 .. (n `div` 2)]

 

let cls n = let ali = take 16 $ aliquot n in (classify ali, ali)

mapM_ (print . cls) $ [1..10] ++

{{out}}

<pre>(Terminating,[1,0])

=={{header|J}}==

Implementation:

aliquot=: +/@proper_divisors ::0:

rc_aliquot_sequence=: aliquot^:(i.16)&>

end.

)

 

Task example:

terminate 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

terminate 2 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0

cyclic 1064 1336 1184 1210 1184 1210 1184 1210 1184 1210 1184 1210 1184 1210 1184 1210

non-terminating 1488 2480 3472 4464 8432 9424 10416 21328 22320 55056 95728 96720 236592 459792 881392 882384

 

=={{header|Java}}==

Translation of [[Aliquot_sequence_classifications#Python|Python]] via [[Aliquot_sequence_classifications#D|D]]

{{works with|Java|8}}

import java.util.Arrays;

import java.util.List;

Arrays.stream(arr).forEach(n -> aliquot(n, 16, 1L << 47));

}

 

<pre>Terminating: [1, 0]

=={{header|jq}}==

{{works with|jq|1.4}}

# than jq 1.4

def until(cond; next):

790, 909, 562, 1064, 1488, 15355717786080) | pp);

{{out}}

1: terminating: [1,0]

2: terminating: [2,1,0]

1064: cyclic back to 1184: [1064,1336,1184,1210]

1488: non-terminating: [1488,2480,3472,4464,8432,9424,10416,21328,22320,55056,95728,96720,236592,459792,881392,882384]

 

=={{header|Julia}}==

'''Core Function'''

function aliquotclassifier{T<:Integer}(n::T)

a = T[n]

return ("Non-terminating", a)

end

 

'''Supporting Functions'''

function pcontrib{T<:Integer}(p::T, a::T)

n = one(T)

dsum -= n

end

 

'''Main'''

 

println("Classification Tests:")

println(@sprintf("%8d => ", i), @sprintf("%16s, ", class), a)

end

 

{{out}}

 

=={{header|Kotlin}}==

 

data class Classification(val sequence: List<Long>, val aliquot: String)

val (seq, aliquot) = classifySequence(k)

println("$k: ${aliquot.padEnd(15)} $seq")

 

{{out}}

 

There are no sociable sequences.

print "ROSETTA CODE - Aliquot sequence classifications"

[Start]

next

end function

 

{{out}}

 

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

NestList[If[# == 0, 0,

DivisorSum[#, # &, Function[div, div != #]]] &, n, 16];

Print[{#, class[seq[#]], notate[seq[#]] /. {0} -> 0}] & /@ {1, 2, 3, 4, 5, 6, 7,

8, 9, 10, 11, 12, 28, 496, 220, 1184, 12496, 1264460, 790, 909,

{{out}}

<pre>{1, Terminating, {1, 0}}

 

=={{header|Nim}}==

import math

import strformat

echo ""

echo fmt"Processed in {(getTime() - t0).inMilliseconds} ms."

 

{{out}}

=={{header|Oforth}}==

 

import: quicksort

import: math

]

"non-terminating"

 

{{out}}

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

Define function aliquot(). Works with recent versions of PARI/GP >= 2.8:

{

my (L = List(x), M = Map(Mat([x,1])), k, m = "non-term.", n = x);

);

printf("%16d: %10s, %s\n", x, m, Vec(L));

 

Output:

=={{header|Perl}}==

{{libheader|ntheory}}

 

sub aliquot {

my($class, @seq) = aliquot($n);

printf "%14d %10s [@seq]\n", $n, $class;

{{out}}

<pre> 1 terminates [1 0]

=={{header|Phix}}==

Translated from the Python example

<span style="color: #008080;">function</span> <span style="color: #000000;">aliquot</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">n</span><span style="color: #0000FF;">}</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;">"%14d =&gt; %15s, {%s}\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">n</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #000000;">classification</span><span style="color: #0000FF;">,</span><span style="color: #000000;">dseq</span><span style="color: #0000FF;">})</span>

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

{{out}}

<pre>

=={{header|Picat}}==

{{trans|C++}}

Total = 1,

Power = 2,

nl

end.

{{out}}

<pre>

{{works with|PowerShell|4.0}}<br/>

<b>Simple</b>

{

If ( $X -gt 1 )

(1..10).ForEach{ [string]$_ + " is " + ( Classify-AlliquotSequence -Sequence ( Get-AliquotSequence -K $_ -N 16 ) ) }

<b>Optimized</b>

{

If ( $X -gt 1 )

(1..10).ForEach{ [string]$_ + " is " + ( Classify-AlliquotSequence -Sequence ( Get-AliquotSequence -K $_ -N 16 ) ) }

{{out}}

<pre>1 is terminating

 

===Version 3.0===

function Get-Aliquot

{

}

}

$oneToTen = 1..10 | Get-Aliquot

$selected = 11, 12, 28, 496, 220, 1184, 12496, 1264460, 790, 909, 562, 1064, 1488 | Get-Aliquot

$numbers = $oneToTen, $selected

$numbers

{{Out}}

<pre>

{{trans|C++}}

{{works with|SWI Prolog}}

divisor_sum(N, Total):-

divisor_sum_prime(N, 2, 2, Total1, 1, N1),

write_aliquot_sequence(N, Sequence, Class),

fail.

 

{{out}}

Importing [[Proper_divisors#Python:_From_prime_factors|Proper divisors from prime factors]]:

 

from functools import lru_cache

 

print()

for n in [11, 12, 28, 496, 220, 1184, 12496, 1264460, 790, 909, 562, 1064, 1488, 15355717786080]:

 

{{out}}

{{works with|QBasic|1.1}}

{{trans|Liberty BASIC}}

DECLARE SUB PrintAliquotClassifier (K!)

CLS

IF clase = 0 THEN COLOR 12: PRINT " non-terminating"

COLOR 7

{{out}}

<pre>Number 1 : 0 Terminating

'''fold-divisors''' is used from [[Proper_divisors#Racket]], but for the truly big numbers, we use divisors from math/number-theory.

 

(require "proper-divisors.rkt" math/number-theory)

 

 

(for ((i (in-list '(11 12 28 496 220 1184 12496 1264460 790 909 562 1064 1488 15355717786080))))

 

{{out}}

(formerly Perl 6)

{{works with|rakudo|2018.10}}

my @l = x > 1;

(2 .. x.sqrt.floor).map: -> \d {

11, 12, 28, 496, 220, 1184, 12496, 1264460,

790, 909, 562, 1064, 1488,

{{out}}

<pre>1 terminating [1]

 

Both of the above limitations are imposed by this Rosetta Code task's restriction requirements: &nbsp; ''For the purposes of this task, ···''.

parse arg low high $L /*obtain optional arguments from the CL*/

high= word(high low 10,1); low= word(low 1,1) /*obtain the LOW and HIGH (range). */

if j*j==x then s= s + j /*Was X a square? If so, add √ X */

#.x= s /*memoize division sum for argument X.*/

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

(Shown at three-quarter size.)

 

=={{header|Ring}}==

# Project : Aliquot sequence classnifications

 

next

return pdtotal

Output:

<pre>

{{trans|Python}}

 

return "terminating", [0] if n == 0

s = []

for n in [11, 12, 28, 496, 220, 1184, 12496, 1264460, 790, 909, 562, 1064, 1488, 15355717786080]

puts "%20s: %p" % aliquot(n)

 

{{out}}

 

=={{header|Rust}}==

enum AliquotType { Terminating, Perfect, Amicable, Sociable, Aspiring, Cyclic, NonTerminating }

 

println!("{} {:?}", num, classify_aliquot(*num));

}

{{out}}

<pre>

=={{header|Scala}}==

Put [[proper_divisors#Scala]] the full /Proper divisors for big (long) numbers/ section to the beginning:

val sum = properDivisors(n).sum

if (sum == 0) ("terminate", list ::: List(sum))

val result = numbers.map(i => createAliquotSeq(i, 0, List(i)))

 

 

{{out}}

=={{header|Swift}}==

 

@inlinable

public func factors(sorted: Bool = true) -> [Self] {

print()

 

 

{{out}}

This solution creates an iterator from a coroutine to generate aliquot sequences. al_classify uses a "RESULT" exception to achieve some unusual control flow.

 

if {$n == 1} {return 0}

set divs 1

puts [time {

puts [format "%8d -> %-16s : %s" $i {*}[al_classify $i]]

 

{{out}}

 

=={{header|VBA}}==

 

Private Type Aliquot

SumPDiv = t

End Function

 

{{out}}

=={{header|Vlang}}==

{{trans|Go}}

const threshold = u64(1) << 47

seq, aliquot := classify_sequence(k)

println("$k: ${aliquot:-15} $seq")

 

{{out}}

{{libheader|Wren-math}}

{{libheader|Wren-seq}}

import "/math" for Int, Nums

import "/seq" for Lst

var c = classifySequence.call(k)

var seq = c.seq.map { |i| Conv.dec(i) }.toList // ensure 15 digit integer is printed in full

 

{{out}}

=={{header|Yabasic}}==

{{trans|FreeBASIC}}

// by Galileo, 05/2022

 

if not n break

alliquot(n)

{{out}}

<pre>Integer: 1, Type: Terminating, Series: 1

 

=={{header|zkl}}==

fcn aliquot(k){ //-->Walker

Walker(fcn(rk){ k:=rk.value; if(k)rk.set(properDivs(k).sum()); k }.fp(Ref(k)))

Or, refactoring to remove saving the intermediate divisors (and adding white space):

Walker(fcn(rk){

k:=rk.value;

k

}.fp(Ref(k)))

const MAX=(2).pow(47); // 140737488355328

ak,aks:=aliquot(k), ak.walk(16);

else "non-terminating" )

+ " " + aks.filter();

T(11,12,28,496,220,1184,12496,1264460,790,909,562,1064,1488)

{{out}}

<pre>

{{trans|AWK}}

This program is correct. However, a bug in the ROM of the ZX Spectrum makes the number 909 of an erroneous result. However, the same program running on Sam BASIC (a superset of Sinclair BASIC that ran on the computer Sam Coupé) provides the correct results.

20 INPUT "Enter a number (0 to end): ";k: IF k>0 THEN GO SUB 2000: PRINT k;" ";s$: GO TO 20

40 STOP

2320 NEXT t

2330 LET s$="non-terminating (after 16 terms)"+s$

{{out}}

<pre>Number classification sequence