Practical numbers: Difference between revisions

{{trans|Nim}}

V result = [1]

L(i) 2 .. Int(sqrt(n))

print(‘Found ’count‘ practical numbers between 1 and 333.’)

print()

{{out}}

=={{header|APL}}==

{{works with|Dyalog APL}}

{{out}}

1 2 4 6 8 12 16 18 20 24 28 30 32 36 40 42 48 54 56 60 64 66 72 78 80 84 88 90 96 100 104 108 112 120 126 128 132 140 144

150 156 160 162 168 176 180 192 196 198 200 204 208 210 216 220 224 228 234 240 252 256 260 264 270 272 276 280 288

294 300 304 306 308 312 320 324 330

pract 666 ⍝ Is 666 practical?

=={{header|C#|CSharp}}==

class Program {

Write("\nFound {0} practical numbers between 1 and {1} inclusive.\n", c, m);

do Write("\n{0,5} is a{1}practical number.",

{{out}}

<pre> 1 2 4 6 8 12 16 18 20 24

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

{{trans|Phix}}

#include <iostream>

#include <numeric>

<< "a practical number.\n";

return 0;

{{out}}

=={{header|FreeBASIC}}==

'produces a list of an integer's proper divisors

for i as uinteger = n/2 to 1 step -1

for n as uinteger = 2 to 666

if is_practical(n) then print n;" ";

All practical numbers up to and including the stretch goal of DCLXVI.

{{trans|Wren}}

{{libheader|Go-rcu}}

import (

fmt.Println(" The final ten are", practical[len(practical)-10:])

fmt.Println("\n666 is practical:", isPractical(666))

{{out}}

Borrowed from the [[Proper divisors#J]] page:

Borrowed from the [[Power set#J]] page:

Implementation:

Task examples:

77

(#~ isPrac) 1+i.333 NB. list them

1 2 4 6 8 12 16 18 20 24 28 30 32 36 40 42 48 54 56 60 64 66 72 78 80 84 88 90 96 100 104 108 112 120 126 128 132 140 144 150 156 160 162 168 176 180 192 196 198 200 204 208 210 216 220 224 228 234 240 252 256 260 264 270 272 276 280 288 294 300 304 306 30...

isPrac 666 NB. test

=={{header|Java}}==

{{trans|Phix}}

public class PracticalNumbers {

return str.toString();

}

{{out}}

The version of `proper_divisors` at [[Proper_divisors#jq]] may be used and therefore its definition

is not repeated here.

# include "proper_divisors" { search: "." };

task(333),

(666,6666,66666

{{out}}

<pre>

=={{header|Julia}}==

{{trans|Python}}

""" proper divisors of n """

println("$n is ", ispractical(n) ? "" : "not ", "a practical number.")

end

<pre>

There are 77 practical numbers between 1 to 333 inclusive.

=={{header|Nim}}==

func properDivisors(n: int): seq[int] =

echo "Found ", count, " practical numbers between 1 and 333."

echo()

{{out}}

because the inequality above holds for each of its prime factors:

3 ≤ σ(2) + 1 = 4, 29 ≤ σ(2 × 3^2) + 1 = 40, and 823 ≤ σ(2 × 3^2 × 29) + 1 = 1171. </pre>

{$IFDEF FPC}

{$MODE DELPHI}{$OPTIMIZATION ON,ALL}

{$IFNDEF UNIX} readln; {$ENDIF}

end.

{{out}}

<pre> TIO.RUN.

==={{header|alternative}}===

Now without generating sum of allset.

{$IFDEF FPC}

{$ENDIF}

end.

{{out}}

<pre> TIO.RUN

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use feature 'say';

say @pn . " matching numbers:\n" . (sprintf "@{['%4d' x @pn]}", @pn) =~ s/(.{40})/$1\n/gr;

say '';

{{out}}

<pre>77 matching numbers:

=={{header|Phix}}==

{{trans|Python|(the composition of functions version)}}

<span style="color: #008080;">function</span> <span style="color: #000000;">sum_of_any_subset</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;">f</span><span style="color: #0000FF;">)</span>

<span style="color: #000080;font-style:italic;">-- return true if any subset of f sums to n.</span>

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

<span style="color: #7060A8;">papply</span><span style="color: #0000FF;">({</span><span style="color: #000000;">666</span><span style="color: #0000FF;">,</span><span style="color: #000000;">6666</span><span style="color: #0000FF;">,</span><span style="color: #000000;">66666</span><span style="color: #0000FF;">,</span><span style="color: #000000;">672</span><span style="color: #0000FF;">,</span><span style="color: #000000;">720</span><span style="color: #0000FF;">},</span><span style="color: #000000;">stretch</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

===Python: Straight forward implementation===

from typing import List, Tuple

print(' ', str(p[:10])[1:-1], '...', str(p[-10:])[1:-1])

x = 666

{{out}}

An extra check on the sum of all factors has a minor positive effect too.

"""Practical number test with factor reverse sort and short-circuiting."""

print(f"\nSTRETCH GOAL: {x} is {'not ' if not is_practical(x) else ''}Practical.")

x = 5184

{{out}}

===Composition of pure functions===

from itertools import accumulate, chain, groupby, product

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>77 OEIS A005153 numbers in [1..333]

=={{header|Raku}}==

sub is-practical ($n) {

given [ (1..333).hyper(:32batch).grep: { is-practical($_) } ];

{{out}}

<pre>77 matching numbers:

=={{header|Rust}}==

{{trans|Phix}}

let len = f.len();

if len == 0 {

}

}

{{out}}

=={{header|Sidef}}==

Built-in:

Slow implementation (as the task requires):

var set = Set()

for n in ([666, 6666, 66666]) {

say "#{'%5s' % n } is practical? #{is_practical(n)}"

Efficient algorithm:

n.is_odd && return (n == 1)

return true

{{out}}

<pre>

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

{{trans|C#}}

Module Module1

Write(vbLf & "{0,5} is a{1}practical number.", m, If(ip(m), " ", "n im")) : Loop While m < 1e4

End Sub

{{out}}

Same as C#

=={{header|Wren}}==

{{libheader|Wren-math}}

var powerset // recursive

System.print(" The first ten are %(practical[0..9])")

System.print(" The final ten are %(practical[-10..-1])")

{{out}}