Attractive numbers: Difference between revisions

{{trans|Python}}

 

I n < 2

R 0B

r.append(L.index)

 

 

{{out}}

=={{header|8080 Assembly}}==

 

MAX: equ 120 ; can be up to 255 (8 bit math is used)

;;; CP/M calls

ppage: equ 3 ; primes in page 3

fctrs: equ 256*fcpage

 

{{out}}

=={{header|Action!}}==

{{libheader|Action! Sieve of Eratosthenes}}

 

BYTE FUNC IsAttractive(BYTE n BYTE ARRAY primes)

FI

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Attractive_numbers.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

{{trans|C}}

 

procedure Attractive_Numbers is

begin

Show_Attractive (Max => 120);

 

{{out}}

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

{{libheader|ALGOL 68-primes}}

# prime, n must be > 1 #

PR read "primes.incl.a68" PR

OD;

print( ( newline, "Found ", whole( a count, 0 ), " attractive numbers", newline ) )

{{out}}

<pre>

 

=={{header|ALGOL W}}==

begin

% implements the sieve of Eratosthenes %

for i := 2 until maxNumber do if s( countPrimeFactors( i, s ) ) then writeon( i )

end

{{out}}

<pre>

 

=={{header|AppleScript}}==

if (n < 4) then return (n > 1)

if ((n mod 2 is 0) or (n mod 3 is 0)) then return false

if (isPrime(primeFactorCount(n))) then set end of output to n

end repeat

 

{{output}}

 

It's possible of course to dispense with the isPrime() handler and instead use primeFactorCount() to count the prime factors of its own output, with 1 indicating an attractive number. The loss of performance only begins to become noticeable in the unlikely event of needing 300,000 or more such numbers!

=={{header|Arturo}}==

 

 

 

{{out}}

 

=={{header|AutoHotkey}}==

c := prime_numbers(n).count()

if c = 1

ans.push(n)

return ans

loop

{

}

MsgBox, 262144, ,% result

{{out}}

<pre> 4 6 8 9 10 12 14 15 18 20 21 22 25 26 27 28 30 32 33 34

 

=={{header|AWK}}==

# syntax: GAWK -f ATTRACTIVE_NUMBERS.AWK

# converted from C

return(1)

}

{{out}}

<pre>

 

=={{header|BASIC}}==

20 M=120

30 DIM C(M): C(0)=-1: C(1)=-1

110 NEXT

120 IF NOT C(C) THEN PRINT I,

{{out}}

<pre> 4 6 8 9 10

 

=={{header|BCPL}}==

manifest $( MAXIMUM = 120 $)

 

$)

wrch('*N')

{{out}}

<pre> 4 6 8 9 10 12 14 15 18 20 21 22 25 26 27 28 30 32

=={{header|C}}==

{{trans|Go}}

 

#define TRUE 1

printf("\n");

return 0;

 

{{out}}

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

{{trans|D}}

 

namespace AttractiveNumbers {

}

}

{{out}}

<pre>The attractive numbers up to and including 120 are:

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

{{trans|C}}

#include <iomanip>

 

cout << endl;

return 0;

 

{{out}}

 

=={{header|CLU}}==

prime: array[bool] := array[bool]$fill(1,max,true)

prime[1] := false

end

end

{{out}}

<pre> 4 6 8 9 10 12 14 15 18 20 21 22 25 26 27

102 105 106 108 110 111 112 114 115 116 117 118 119 120</pre>

=={{header|COBOL}}==

PROGRAM-ID. ATTRACTIVE-NUMBERS.

 

GO TO SET-COMPOSITES-LOOP.

DONE.

{{out}}

<pre> 4 6 8 9 10 12 14 15 18 20 21 22 25 26 27 28 30 32

 

=={{header|Comal}}==

0020 count#:=0

0030 WHILE n# MOD 2=0 DO n#:=n# DIV 2;count#:+1

0200 ENDFOR i#

0210 PRINT

{{out}}

<pre>4 6 8 9 10 12 14 15 18 20 21 22 25 26 27 28 30 32

 

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

(defun attractivep (n)

(primep (length (factors n))) )

(cond ((> d max-d) (return (list n))) ; n is prime

((zerop (rem n d)) (return (cons d (factors (truncate n d)))))))))

{{out}}

<pre>(dotimes (i 121) (when (attractivep i) (princ i) (princ " ")))

 

=={{header|Cowgol}}==

const MAXIMUM := 120;

 

cand := cand + 1;

end loop;

{{out}}

<pre> 4 6 8 9 10 12 14 15 18 20 21 22 25 26 27 28 30 32

=={{header|D}}==

{{trans|C++}}

 

enum MAX = 120;

}

writeln;

{{out}}

<pre>The attractive numbers up to and including 120 are:

See [[#Pascal]].

=={{header|Draco}}==

proc nonrec sieve([*] bool prime) void:

word p, c, max;

fi

od

{{out}}

<pre> 4 6 8 9 10 12 14 15 18 20 21 22 25 26 27 28 30 32

 

=={{header|F_Sharp|F#}}==

// taken from Primality by trial division

let rec primes =

|> List.filter is_attractive

|> List.iteri print_iter

{{out}}

<pre>>dotnet fsi attractive_numbers.fsx

=={{header|Factor}}==

{{works with|Factor|0.99}}

math.ranges sequences ;

 

"The attractive numbers up to and including 120 are:" print

120 [1,b] [ factors length prime? ] filter 20 <groups>

{{out}}

<pre>

=={{header|Fortran}}==

{{trans|C++}}

program attractive_numbers

use iso_fortran_env, only: output_unit

end function count_prime_factors

end program attractive_numbers

 

{{out}}

=={{header|FreeBASIC}}==

{{trans|D}}

Const limite = 120

 

Wend

End

{{out}}

<pre>

 

=={{header|Frink}}==

{{out}}

<pre>

=={{header|Go}}==

Simple functions to test for primality and to count prime factors suffice here.

 

import "fmt"

}

fmt.Println()

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

static boolean isPrime(int n) {

if (n < 2) return false

println()

}

{{out}}

<pre>The attractive numbers up to and including 120 are:

 

=={{header|Haskell}}==

import Data.Bool (bool)

 

 

main :: IO ()

 

Or equivalently, as a list comprehension:

 

attractiveNumbers :: [Integer]

 

main :: IO ()

 

Or simply:

 

attractiveNumbers :: [Integer]

 

main :: IO ()

{{Out}}

<pre>[4,6,8,9,10,12,14,15,18,20,21,22,25,26,27,28,30,32,33,34,35,38,39,42,44,45,46,48,49,50,51,52,55,57,58,62,63,65,66,68,69,70,72,74,75,76,77,78,80,82,85,86,87,91,92,93,94,95,98,99,102,105,106,108,110,111,112,114,115,116,117,118,119,120]</pre>

 

=={{header|J}}==

echo (#~ (1 p: ])@#@q:) >:i.120

{{out}}

<pre>

 

=={{header|JavaScript}}==

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre> 4 6 8 9 10 12 14 15 18 20

=={{header|Java}}==

{{trans|C}}

 

static boolean is_prime(int n) {

System.out.println();

}

 

{{out}}

* `is_prime` as defined at [[Erd%C5%91s-primes#jq | Erdős primes]] on RC

* `prime_factors` as defined at [[Smith_numbers#jq | Smith numbers]] on RC

def count(s): reduce s as $x (null; .+1);

 

[range($m; $n+1) | select(is_attractive)];

{{out}}

<pre>

 

=={{header|Julia}}==

 

# oneliner is println("The attractive numbers from 1 to 120 are:\n", filter(x -> isprime(sum(values(factor(x)))), 1:120))

printattractive(1, 120)

<pre>

The attractive numbers from 1 to 120 are:

=={{header|Kotlin}}==

{{trans|Go}}

 

const val MAX = 120

}

println()

 

{{output}}

 

=={{header|LLVM}}==

; LLVM does not provide a way to print values, so the alternative would be

; to just load the string into memory, and that would be boring.

}

 

{{out}}

<pre>The attractive numbers up to and including 120 are:

 

=={{header|Lua}}==

function isPrime (x)

if x < 2 then return false end

for i = 1, 120 do

if isPrime(#factors(i)) then io.write(i .. "\t") end

{{out}}

<pre>4 6 8 9 10 12 14 15 18 20 21 22 25 26 27

 

=={{header|Maple}}==

local an, i;

an :=[]:

end do:

end proc:

{{out}}

<pre>[4, 6, 8, 9, 10, 12, 14, 15, 18, 20, 21, 22, 25, 26, 27, 28, 30, 32, 33, 34, 35, 38, 39, 42, 44, 45, 46, 48, 49, 50, 51, 52, 55, 57, 58, 62, 63, 65, 66, 68, 69, 70, 72, 74, 75, 76, 77, 78, 80, 82, 85, 86, 87, 91, 92, 93, 94, 95, 98, 99, 102, 105, 106, 108, 110, 111, 112, 114, 115, 116, 117, 118, 119, 120]</pre>

 

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

AttractiveNumberQ[n_Integer] := FactorInteger[n][[All, 2]] // Total // PrimeQ

{{out}}

<pre>{4,6,8,9,10,12,14,15,18,20,21,22,25,26,27,28,30,32,33,34,35,38,39,42,44,45,46,48,49,50,51,52,55,57,58,62,63,65,66,68,69,70,72,74,75,76,77,78,80,82,85,86,87,91,92,93,94,95,98,99,102,105,106,108,110,111,112,114,115,116,117,118,119,120}</pre>

 

=={{header|Modula-2}}==

FROM InOut IMPORT WriteCard, WriteLn;

 

END;

WriteLn();

{{out}}

<pre> 4 6 8 9 10 12 14 15 18 20 21 22 25 26 27

=={{header|Nanoquery}}==

{{trans|C}}

 

def is_prime(n)

end

end

 

{{out}}

The ''factor'' function returns a list of the prime factors of an integer with repetition,

e. g. (factor 12) is (2 2 3).

(define (prime? n)

(= (length (factor n)) 1))

;

(filter attractive? (sequence 2 120))

{{out}}

<pre>

=={{header|Nim}}==

{{trans|C}}

 

const MAX = 120

 

main()

{{out}}

<pre>The attractive numbers up to and including 120 are:

{{trans|Java}}

 

function : Main(args : String[]) ~ Nil {

max := 120;

return -1;

}

 

{{output}}

{{works with|Free Pascal}}

same procedure as in http://rosettacode.org/wiki/Abundant,_deficient_and_perfect_number_classifications

{ numbers with count of factors = prime

* using modified sieve of erathosthes

writeln('time counting : ',T*86400 :8:3,' s');

writeln('time total : ',(now-T0)*86400 :8:3,' s');

{{out}}

<pre> 1 with many factors 0.000 s

=={{header|Perl}}==

{{libheader|ntheory}}

 

{{out}}

<pre>4 6 8 9 10 12 14 15 18 20 21 22 25 26 27 28 30 32 33 34 35 38 39 42 44 45 46 48 49 50 51 52 55 57 58 62 63 65 66 68 69 70 72 74 75 76 77 78 80 82 85 86 87 91 92 93 94 95 98 99 102 105 106 108 110 111 112 114 115 116 117 118 119 120</pre>

 

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">attractive</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">lim</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: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"There are %,d attractive numbers up to %,d (%s)\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">l</span><span style="color: #0000FF;">,</span><span style="color: #000000;">p</span><span style="color: #0000FF;">,</span><span style="color: #000000;">e</span><span style="color: #0000FF;">})</span>

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

{{out}}

<pre>

 

=={{header|PHP}}==

function isPrime ($x) {

if ($x < 2) return false;

if (isPrime(countFacs($i))) echo $i."&ensp;";

}

{{out}}

<pre>4 6 8 10 12 14 15 18 20 21 22 26 27 28 30 32 33 34 35 36 38 39 42 44 45 46 48 50 51 52 55 57 58 62 63 65 66 68 69 70 74 75 76 77 78 80 82 85 86 87 91 92 93 94 95 98 99 100 102 105 106 108 110 111 112 114 115 116 117 118 119 120</pre>

 

=={{header|PL/I}}==

%replace MAX by 120;

declare prime(1:MAX) bit(1);

end;

end;

{{out}}

<pre> 4 6 8 9 10 12 14 15 18 20 21 22 25 26 27 28 30 32

 

=={{header|PL/M}}==

BDOS: PROCEDURE (F, ARG); DECLARE F BYTE, ARG ADDRESS; GO TO 5; END BDOS;

EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;

END;

CALL EXIT;

{{out}}

<pre> 4 6 8 9 10 12 14 15 18 20 21 22 25 26 27 28 30 32

=={{header|Prolog}}==

{{works with|SWI Prolog}}

S is sqrt(N),

prime_factors(N, Factors, S, 2).

 

main:-

 

{{out}}

 

=={{header|PureBasic}}==

Dim prime.b(#MAX)

FillMemory(@prime(),#MAX,#True,#PB_Byte) : FillMemory(@prime(),2,#False,#PB_Byte)

EndIf

Next

{{out}}

<pre>The attractive numbers up to and including 120 are:

===Procedural===

{{Works with|Python|2.7.12}}

 

def get_pfct(n):

for i,each in enumerate(pool):

if each in primes:

{{out}}

<pre>4,6,8,9,10,12,14,15,18,20,21,22,25,26,27,28,30,32,33,34,35,38,39,42,44,45,46, 48,49,50,51,52,55,57,58,62,63,65,66,68,69,70,72,74,75,76,77,78,80,82,85,86,87, 91,92,93,94,95,98,99,102,105,106,108,110,111,112,114,115,116,117,118,119,120</pre>

Without importing a primes library – at this scale a light and visible implementation is more than enough, and provides more material for comparison.

{{Works with|Python|3.7}}

 

from itertools import chain, count, takewhile

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre> 4 6 8 9 10 12 14 15 18 20 21 22 25 26 27

<code>primefactors</code> is defined at [https://rosettacode.org/wiki/Prime_decomposition#Quackery Prime decomposition].

 

primefactors size 1 = ] is attractive ( n --> b )

 

120 times

[ i^ 1+ attractive if

 

{{out}}

 

=={{header|R}}==

is_prime <- function(num) {

if (num < 2) return(FALSE)

}

}

{{out}}

<pre>

 

=={{header|Racket}}==

(require math/number-theory)

(define attractive? (compose1 prime? prime-omega))

 

{{out}}

This algorithm is concise but not really well suited to finding large quantities of consecutive attractive numbers. It works, but isn't especially speedy. More than a hundred thousand or so gets tedious. There are other, much faster (though more verbose) algorithms that ''could'' be used. This algorithm '''is''' well suited to finding '''arbitrary''' attractive numbers though.

 

use ntheory:from<Perl5> <factor is_prime>;

 

put "\nCount of attractive numbers from {comma $a} to {comma $b}:\n" ~

comma count $a, $b

{{out}}

<pre>Attractive numbers from 1 to 120:

 

If the argument for the program is negative, &nbsp; only a &nbsp; ''count'' &nbsp; of attractive numbers up to and including &nbsp; '''│N│''' &nbsp; is shown.

parse arg N . /*get optional argument from the C.L. */

if N=='' | N=="," then N= 120 /*Not specified? Then use the default.*/

do j=3 by 2 until p==n; do k=3 by 2 until k*k>j; if j//k==0 then iterate j

end /*k*/; @.j = 1; p= p + 1

This REXX program makes use of &nbsp; '''LINESIZE''' &nbsp; REXX program (or BIF) which is used to determine the

screen width (or linesize) of the terminal (console).

 

=={{header|Ring}}==

# Project: Attractive Numbers

 

next

return 1

{{out}}

<pre>

 

=={{header|Ruby}}==

p (1..120).select{|n| n.prime_division.sum(&:last).prime? }

{{out}}<pre>[4, 6, 8, 9, 10, 12, 14, 15, 18, 20, 21, 22, 25, 26, 27, 28, 30, 32, 33, 34, 35, 38, 39, 42, 44, 45, 46, 48, 49, 50, 51, 52, 55, 57, 58, 62, 63, 65, 66, 68, 69, 70, 72, 74, 75, 76, 77, 78, 80, 82, 85, 86, 87, 91, 92, 93, 94, 95, 98, 99, 102, 105, 106, 108, 110, 111, 112, 114, 115, 116, 117, 118, 119, 120]

</pre>

=={{header|Rust}}==

Uses [https://crates.io/crates/primal primal]

 

const MAX: u64 = 120;

}

println!("The attractive numbers up to and including 120 are\n{:?}", output);

{{out}}<pre>The attractive numbers up to and including 120 are

[4, 6, 8, 9, 10, 12, 14, 15, 18, 20, 21, 22, 25, 26, 27, 28, 30, 32, 33, 34, 35, 38, 39, 42, 44, 45, 46, 48, 49, 50, 51, 52, 55, 57, 58, 62, 63, 65, 66, 68, 69, 70, 72, 74, 75, 76, 77, 78, 80, 82, 85, 86, 87, 91, 92, 93, 94, 95, 98, 99, 102, 105, 106, 108, 110, 111, 112, 114, 115, 116, 117, 118, 119, 120]</pre>

=={{header|Scala}}==

{{Out}}Best seen in running your browser either by [https://scalafiddle.io/sf/23oE3SQ/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/U0QUQu0uTT24vbDEHU1c0Q Scastie (remote JVM)].

private val max = 120

private var count = 0

.groupBy { case (_, index) => index / 20 }

.foreach { case (_, row) => println(row.map(_._1).mkString) }

 

=={{header|Sidef}}==

n.bigomega.is_prime

}

 

{{out}}

<pre>[4, 6, 8, 9, 10, 12, 14, 15, 18, 20, 21, 22, 25, 26, 27, 28, 30, 32, 33, 34, 35, 38, 39, 42, 44, 45, 46, 48, 49, 50, 51, 52, 55, 57, 58, 62, 63, 65, 66, 68, 69, 70, 72, 74, 75, 76, 77, 78, 80, 82, 85, 86, 87, 91, 92, 93, 94, 95, 98, 99, 102, 105, 106, 108, 110, 111, 112, 114, 115, 116, 117, 118, 119, 120]</pre>

=={{header|Swift}}==

 

 

extension BinaryInteger {

let attractive = Array((1...).lazy.filter({ $0.isAttractive }).prefix(while: { $0 <= 120 }))

 

 

{{out}}

 

=={{header|Tcl}}==

if {$n < 2} {

return 0

}

}

{{out}}

<pre>Attractive numbers in range 1..120 are:

=={{header|Vala}}==

{{trans|D}}

var d = 5;

if (n < 2) return false;

}

stdout.printf("\n");

 

{{out}}

 

=={{header|VBA}}==

 

Public Sub AttractiveNumbers()

 

Finish2:

 

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

{{trans|D}}

Const MAX = 120

 

End Sub

 

{{out}}

<pre>The attractive numbers up to and including 120 are:

=={{header|Vlang}}==

{{trans|Go}}

if n < 2 {

return false

}

}

 

{{out}}

{{libheader|Wren-fmt}}

{{libheader|Wren-math}}

import "/math" for Int

}

}

 

{{out}}

 

=={{header|XPL0}}==

int N, I;

[if N <= 2 then return N = 2;

if rem(C/10) then ChOut(0, 9\tab\) else CrLf(0);

];

 

{{out}}

Using GMP (GNU Multiple Precision Arithmetic Library, probabilistic

primes) because it is easy and fast to test for primeness.

fcn attractiveNumber(n){ BI(primeFactors(n).len()).probablyPrime() }

 

println("The attractive numbers up to and including 120 are:");

[1..120].filter(attractiveNumber)

Using [[Prime decomposition#zkl]]

acc:=fcn(n,k,acc,maxD){ // k is 2,3,5,7,9,... not optimum

if(n==1 or k>maxD) acc.close();

if(n!=m) acc.append(n/m); // opps, missed last factor

else acc;

{{out}}

<pre>