Aliquot sequence classifications: Difference between revisions

{{trans|Python}}

 

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

 

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

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

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

# aliquot sequence classification #

# maximum sequence length we consider #

=={{header|AppleScript}}==

 

if (n < 2) then return 0

set sum to 1

 

{{output}}

1: terminating 1, 0

2: terminating 2, 1, 0

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

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

/* ARM assembly Raspberry PI */

/* program aliquotSeq.s */

=={{header|AWK}}==

 

#!/bin/gawk -f

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

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

# by Jjuanhdez, 06/2022

 

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

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

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

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

#include <iostream>

#include <string>

=={{header|CLU}}==

{{trans|C++}}

 

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

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

=={{header|D}}==

{{trans|Python}}

 

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

 

=={{header|EchoLisp}}==

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

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

</syntaxhighlight>

{{out}}

(lib 'math)

(lib 'bigint)

=={{header|Elixir}}==

{{trans|Ruby}}

def divisors(1), do: []

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

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

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.

=={{header|FreeBASIC}}==

{{trans|C}}

dim as ulongint result = 1, i

for i = 1 to power

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

 

=={{header|Haskell}}==

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

 

=={{header|J}}==

Implementation:

aliquot=: +/@proper_divisors ::0:

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

 

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

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;

=={{header|jq}}==

{{works with|jq|1.4}}

# than jq 1.4

def until(cond; next):

task</syntaxhighlight>

{{out}}

1: terminating: [1,0]

2: terminating: [2,1,0]

=={{header|Julia}}==

'''Core Function'''

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

a = T[n]

 

'''Supporting Functions'''

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

n = one(T)

 

'''Main'''

 

println("Classification Tests:")

 

=={{header|Kotlin}}==

 

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

 

There are no sociable sequences.

print "ROSETTA CODE - Aliquot sequence classifications"

[Start]

 

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

NestList[If[# == 0, 0,

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

 

=={{header|Nim}}==

import math

import strformat

=={{header|Oforth}}==

 

import: quicksort

import: math

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

=={{header|Perl}}==

{{libheader|ntheory}}

 

sub aliquot {

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

=={{header|Picat}}==

{{trans|C++}}

Total = 1,

Power = 2,

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

<b>Simple</b>

{

If ( $X -gt 1 )

( 11, 12, 28, 496, 220, 1184, 790, 909, 562, 1064, 1488 ).ForEach{ [string]$_ + " is " + ( Classify-AlliquotSequence -Sequence ( Get-AliquotSequence -K $_ -N 16 ) ) }</syntaxhighlight>

<b>Optimized</b>

{

If ( $X -gt 1 )

 

===Version 3.0===

function Get-Aliquot

{

}

</syntaxhighlight>

$oneToTen = 1..10 | Get-Aliquot

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

{{trans|C++}}

{{works with|SWI Prolog}}

divisor_sum(N, Total):-

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

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

 

from functools import lru_cache

 

{{works with|QBasic|1.1}}

{{trans|Liberty BASIC}}

DECLARE SUB PrintAliquotClassifier (K!)

CLS

'''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)

 

(formerly Perl 6)

{{works with|rakudo|2018.10}}

my @l = x > 1;

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

 

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). */

 

=={{header|Ring}}==

# Project : Aliquot sequence classnifications

 

{{trans|Python}}

 

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

s = []

 

=={{header|Rust}}==

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

 

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

=={{header|Swift}}==

 

@inlinable

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

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

 

=={{header|VBA}}==

 

Private Type Aliquot

=={{header|Vlang}}==

{{trans|Go}}

const threshold = u64(1) << 47

{{libheader|Wren-math}}

{{libheader|Wren-seq}}

import "/math" for Int, Nums

import "/seq" for Lst

=={{header|Yabasic}}==

{{trans|FreeBASIC}}

// by Galileo, 05/2022

 

 

=={{header|zkl}}==

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

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

}(10).walk(15).println();</syntaxhighlight>

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

Walker(fcn(rk){

k:=rk.value;

}.fp(Ref(k)))

}(10).walk(15).println();</syntaxhighlight>

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

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

+ " " + aks.filter();

}</syntaxhighlight>

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

.pump(fcn(k){ "%6d is %s".fmt(k,classify(k)).println() });</syntaxhighlight>

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