Abundant odd numbers: Difference between revisions

{{trans|Python}}

 

V aCount = 0

V dSum = 0

 

=={{header|360 Assembly}}==

ABUNODDS CSECT

USING ABUNODDS,R13 base register

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

[[http://rosettacode.org/wiki/Proper_divisors#Ada]].

 

 

procedure Odd_Abundant is

 

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

# find some abundant odd numbers - numbers where the sum of the proper #

# divisors is bigger than the number #

{{Trans|ALGOL 68}}

Using the divisor_sum procedure from the [[Sum_of_divisors#ALGOL_W]] task.

% find some abundant odd numbers - numbers where the sum of the proper %

% divisors is bigger than the number %

=={{header|AppleScript}}==

 

if (n < 2) then return 0

set sum to 1

{{output}}

 

945 (proper divisor sum: 975)

1575 (proper divisor sum: 1649)

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program abundant.s */

=={{header|Arturo}}==

 

 

print "the first 25 abundant odd numbers:"

 

=={{header|AutoHotkey}}==

sum := 0, str := ""

for n, bool in proper_divisors(num)

return Array

}</syntaxhighlight>

while (count<1000)

{

 

=={{header|AWK}}==

# syntax: GAWK -f ABUNDANT_ODD_NUMBERS.AWK

# converted from C

</pre>

 

{{trans|Visual Basic .NET}}

numimpar = 1

contar = 0

 

=={{header|C}}==

#include <math.h>

 

 

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

using System.Collections.Generic;

using System.Linq;

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

{{trans|Go}}

#include <iostream>

#include <numeric>

 

=={{header|CLU}}==

isqrt = proc (s: int) returns (int)

x0: int := s / 2

Using the ''iterate'' library instead of the standard ''loop'' or ''do''.

 

(eval-when (:compile-toplevel :load-toplevel)

(ql:quickload '("cl-annot" "iterate" "alexandria")))

=={{header|D}}==

{{trans|C++}}

 

int[] divisors(int n) {

=={{header|Delphi}}==

{{trans|C}}

 

{$APPTYPE CONSOLE}

The first abundant odd number above one billion is: 1000000575

</pre>

 

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

// Abundant odd numbers. Nigel Galloway: August 1st., 2021

let fN g=Seq.initInfinite(int64>>(+)1L)|>Seq.takeWhile(fun n->n*n<=g)|>Seq.filter(fun n->g%n=0L)|>Seq.sumBy(fun n->let i=g/n in n+(if i=n then 0L else i))

 

=={{header|Factor}}==

math.primes.factors sequences tools.memory.private ;

IN: rosetta-code.abundant-odd-numbers

A basic direct solution. A more robust alternative would be to find

the prime factors and then use a formulaic approach.

program main

use,intrinsic :: iso_fortran_env, only : int8, int16, int32, int64

=={{header|FreeBASIC}}==

{{trans|Visual Basic .NET}}

Declare Function SumaDivisores(n As Integer) As Integer

 

=={{header|Frink}}==

Frink has efficient functions for factoring numbers that use trial division, wheel factoring, and Pollard rho factoring.

 

n = 3

=={{header|FutureBasic}}==

{{trans|C}}

include "NSLog.incl"

 

local fn SumOfProperDivisors( n as NSUInteger ) as NSUinteger

 

end fn = sum

 

HandleEvents

</syntaxhighlight>

{{out}}

<pre>

 

=={{header|Go}}==

 

import (

=={{header|Groovy}}==

{{trans|Java}}

static List<Integer> divisors(int n) {

List<Integer> divs = new ArrayList<>()

 

=={{header|Haskell}}==

 

divisorSum :: Integral a => a -> a

 

Or, importing Data.Numbers.Primes (and significantly faster):

import Data.Numbers.Primes

 

 

=={{header|Java}}==

import java.util.List;

 

Composing reusable functions and generators:

{{Trans|Python}}

'use strict';

const main = () => {

 

=={{header|jq}}==

# The factors, unsorted

def factors:

 

Computing the first abundant number greater than 10^9 is presently impractical using jq, but for the other tasks:

limit(25; abundant_odd_numbers)),

[],

 

=={{header|Julia}}==

 

function propfact(n)

=={{header|Kotlin}}==

{{trans|D}}

val divs = mutableListOf(1)

val divs2 = mutableListOf<Int>()

=={{header|Lobster}}==

{{trans|C}}

// Note that the following function is for odd numbers only

// Use "for (unsigned i = 2; i*i <= n; i++)" for even and odd numbers

 

=={{header|Lua}}==

function sumDivs (x)

local sum, sqr = 1, math.sqrt(x)

=={{header|MAD}}==

 

INTERNAL FUNCTION(ND)

=={{header|Maple}}==

 

with(NumberTheory):

 

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

 

AbundantQ[n_] := TrueQ[Greater[Total @ Most @ Divisors @ n, n]]

res = {};

 

=={{header|Maxima}}==

while k < 25 do (

n: n+2,

<pre>[[945,1920],[1575,3224],[2205,4446],[2835,5808],[3465,7488],[4095,8736],[4725,9920],[5355,11232],[5775,11904],[5985,12480],[6435,13104],[6615,13680],[6825,13888],[7245,14976],[7425,14880],[7875,16224],[8085,16416],[8415,16848],[8505,17472],[8925,17856],[9135,18720],[9555,19152],[9765,19968],[10395,23040],[11025,22971]]</pre>

 

while k < 1000 do (

n: n+2,

<pre>[492975,1012336]</pre>

 

while n < 10^8 do (

if not mod(n,3)=0 then (

{{out}}

<pre>[5,25,35,175,385,1925,5005,25025,85085,425425,1616615,8083075,37182145,56581525]</pre>

 

=={{header|Nim}}==

from math import sqrt

import strformat

=={{header|Pascal}}==

{{works with|Free Pascal}} {{works with|Delphi}}

program AbundantOddNumbers;

{$IFDEF FPC}

{{trans|Raku}}

{{libheader|ntheory}}

use warnings;

use feature 'say';

 

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">abundantOdd</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: #000000;">done</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">lim</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">bool</span> <span style="color: #000000;">printAll</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">while</span> <span style="color: #000000;">done</span><span style="color: #0000FF;"><</span><span style="color: #000000;">lim</span> <span style="color: #008080;">do</span>

 

=={{header|PicoLisp}}==

(if (assoc Key (val Var))

(con @ (inc (cdr @)))

 

=={{header|Processing}}==

println("First 25 abundant odd numbers: ");

int abundant = 0;

=={{header|PureBasic}}==

{{trans|C}}

 

 

===Procedural===

{{trans|Visual Basic .NET}}

# Abundant odd numbers - Python

 

 

===Functional===

 

from math import sqrt

 

=={{header|q}}==

sd:sum s@ / sum of proper divisors

abundant:{x<sd x}

The definition here is naïve. It suffices for the first two items in this task, but takes minutes to execute the third item on a 2018 Mac with 64GB memory.

{{out}}

1054

 

<code>factors</code> is defined at [[Factors of an integer#Quackery]].

 

 

0 -1 [ 2 +

 

=={{header|R}}==

 

find_div_sum <- function(x){

=={{header|Racket}}==

 

 

(require math/number-theory

{{works with|Rakudo|2019.03}}

 

my @l = x.is-prime ?? 1 !! flat

1, (3 .. x.sqrt.floor).map: -> \d {

 

The &nbsp; '''sigO''' &nbsp; function is a specialized version of the &nbsp; '''sigma''' &nbsp; function optimized just for &nbsp; ''odd'' &nbsp; numbers.

parse arg Nlow Nuno Novr . /*obtain optional arguments from the CL*/

say

leave /*we're finished displaying NUNOth num.*/

say

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

<pre>

 

=={{header|Ring}}==

#Project: Anbundant odd numbers

 

done...

</pre>

 

=={{header|Ruby}}==

proper_divisors method taken from http://rosettacode.org/wiki/Proper_divisors#Ruby

class Integer

=={{header|Rust}}==

{{trans|Go}}

let mut divs = vec![1];

let mut divs2 = Vec::new();

=={{header|Scala}}==

{{trans|D}}

 

object Abundant {

 

=={{header|Sidef}}==

n.sigma > 2*n

}

 

=={{header|Smalltalk}}==

[:nr |

|divs|

=={{header|Swift}}==

 

@inlinable

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

=={{header|uBasic/4tH}}==

{{trans|C}}

For n = 1 Step 2 While c < 25

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

{{Trans|ALGOL 68}}

' find some abundant odd numbers - numbers where the sum of the proper

' divisors is bigger than the number

</pre>

 

{{trans|go}}

mut divs := [i64(1)]

mut divs2 := []i64{}

{{libheader|Wren-fmt}}

{{libheader|Wren-math}}

var sumStr = Fn.new { |divs| divs.reduce("") { |acc, div| acc + "%(div) + " }[0...-3] }

var s = sumStr.call(divs)

if (!printOne) {

} else {

}

}

=={{header|X86 Assembly}}==

Assemble with tasm and tlink /t

.code

.486

 

=={{header|XPL0}}==

[Cnt:= 0;

Num:= 3; \find odd abundant numbers

 

=={{header|zkl}}==

Walker.zero().tweak(fcn(rn){

n:=rn.value;

}.fp(Ref(startAt.isOdd and startAt or startAt+1)))

}</syntaxhighlight>

[3.. n.toFloat().sqrt().toInt(), 2].pump(List(1),'wrap(d){

if( (y:=n/d) *d != n) return(Void.Skip);

}

}</syntaxhighlight>

 

println("First 25 abundant odd numbers:");