Attractive numbers: Difference between revisions

{{trans|Python}}

I n < 2

R 0B

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

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

;;; CP/M calls

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

{{libheader|Action! Sieve of Eratosthenes}}

BYTE FUNC IsAttractive(BYTE n BYTE ARRAY primes)

=={{header|Ada}}==

{{trans|C}}

procedure Attractive_Numbers is

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

{{libheader|ALGOL 68-primes}}

# prime, n must be > 1 #

PR read "primes.incl.a68" PR

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

begin

% implements the sieve of Eratosthenes %

=={{header|AppleScript}}==

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

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

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

print select 1..120 => attractive?</syntaxhighlight>

=={{header|AutoHotkey}}==

c := prime_numbers(n).count()

if c = 1

return ans

}</syntaxhighlight>

loop

{

=={{header|AWK}}==

# syntax: GAWK -f ATTRACTIVE_NUMBERS.AWK

# converted from C

=={{header|BASIC}}==

20 M=120

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

=={{header|BCPL}}==

manifest $( MAXIMUM = 120 $)

=={{header|C}}==

{{trans|Go}}

#define TRUE 1

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

{{trans|D}}

namespace AttractiveNumbers {

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

{{trans|C}}

#include <iomanip>

=={{header|CLU}}==

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

prime[1] := false

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

=={{header|COBOL}}==

PROGRAM-ID. ATTRACTIVE-NUMBERS.

=={{header|Comal}}==

0020 count#:=0

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

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

(defun attractivep (n)

(primep (length (factors n))) )

=={{header|Cowgol}}==

const MAXIMUM := 120;

=={{header|D}}==

{{trans|C++}}

enum MAX = 120;

See [[#Pascal]].

=={{header|Draco}}==

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

word p, c, max;

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

// taken from Primality by trial division

let rec primes =

=={{header|Factor}}==

{{works with|Factor|0.99}}

math.ranges sequences ;

=={{header|Fortran}}==

{{trans|C++}}

program attractive_numbers

use iso_fortran_env, only: output_unit

=={{header|FreeBASIC}}==

{{trans|D}}

Const limite = 120

=={{header|Frink}}==

{{out}}

<pre>

=={{header|Go}}==

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

import "fmt"

=={{header|Groovy}}==

{{trans|Java}}

static boolean isPrime(int n) {

if (n < 2) return false

=={{header|Haskell}}==

import Data.Bool (bool)

Or equivalently, as a list comprehension:

attractiveNumbers :: [Integer]

Or simply:

attractiveNumbers :: [Integer]

=={{header|J}}==

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

</syntaxhighlight>

=={{header|JavaScript}}==

'use strict';

=={{header|Java}}==

{{trans|C}}

static boolean is_prime(int n) {

* `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);

=={{header|Julia}}==

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

=={{header|Kotlin}}==

{{trans|Go}}

const val MAX = 120

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

=={{header|Lua}}==

function isPrime (x)

if x < 2 then return false end

=={{header|Maple}}==

local an, i;

an :=[]:

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

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

Reap[Do[If[AttractiveNumberQ[i], Sow[i]], {i, 120}]][[2, 1]]</syntaxhighlight>

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

FROM InOut IMPORT WriteCard, WriteLn;

=={{header|Nanoquery}}==

{{trans|C}}

def is_prime(n)

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

=={{header|Nim}}==

{{trans|C}}

const MAX = 120

{{trans|Java}}

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

max := 120;

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

=={{header|Perl}}==

{{libheader|ntheory}}

is_prime +factor $_ and print "$_ " for 1..120;</syntaxhighlight>

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

=={{header|PHP}}==

function isPrime ($x) {

if ($x < 2) return false;

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

%replace MAX by 120;

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

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

=={{header|Prolog}}==

{{works with|SWI Prolog}}

S is sqrt(N),

prime_factors(N, Factors, S, 2).

=={{header|PureBasic}}==

Dim prime.b(#MAX)

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

===Procedural===

{{Works with|Python|2.7.12}}

def get_pfct(n):

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

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

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

=={{header|R}}==

is_prime <- function(num) {

if (num < 2) return(FALSE)

=={{header|Racket}}==

(require math/number-theory)

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

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

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

=={{header|Ring}}==

# Project: Attractive Numbers

=={{header|Ruby}}==

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

=={{header|Rust}}==

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

const MAX: u64 = 120;

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

=={{header|Sidef}}==

n.bigomega.is_prime

}

=={{header|Swift}}==

extension BinaryInteger {

=={{header|Tcl}}==

if {$n < 2} {

return 0

=={{header|Vala}}==

{{trans|D}}

var d = 5;

if (n < 2) return false;

=={{header|VBA}}==

Public Sub AttractiveNumbers()

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

{{trans|D}}

Const MAX = 120

=={{header|Vlang}}==

{{trans|Go}}

if n < 2 {

return false

{{libheader|Wren-fmt}}

{{libheader|Wren-math}}

import "/math" for Int

=={{header|XPL0}}==

int N, I;

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

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() }

.apply("%4d".fmt).pump(Void,T(Void.Read,19,False),"println");</syntaxhighlight>

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();