Abundant odd numbers: Difference between revisions

{{trans|Python}}

V aCount = 0

V dSum = 0

print("\nFirst abundant odd number > 1 000 000 000:")

print(‘ ’oddNumber‘ proper divisor sum: ’dSum)

{{out}}

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

ABUNODDS CSECT

USING ABUNODDS,R13 base register

XDEC DS CL12 temp for edit

REGEQU equate registers

{{out}}

<pre>

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

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{output}}

<pre>

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

procedure Odd_Abundant is

end loop;

Print_Abundant_Line(1, Current, False);

{{out}}

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

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

# divisors is bigger than the number #

OD

END

{{out}}

<pre>

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

end while_not_foundOddAn ;

end

{{out}}

<pre>

=={{header|AppleScript}}==

if (n < 2) then return 0

set sum to 1

set output to output as text

set AppleScript's text item delimiters to astid

{{output}}

945 (proper divisor sum: 975)

1575 (proper divisor sum: 1649)

492975 (proper divisor sum: 519361)

The first > 1,000,000,000:

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program abundant.s */

/***************************************************/

.include "../affichage.inc"

<pre>

Program start

=={{header|Arturo}}==

print "the first 25 abundant odd numbers:"

]

'i + 2

{{out}}

=={{header|AutoHotkey}}==

sum := 0, str := ""

for n, bool in proper_divisors(num)

Array[i] := true

return Array

while (count<1000)

{

}

MsgBox % output

{{out}}

<pre>First 25 abundant odd numbers:

=={{header|AWK}}==

# syntax: GAWK -f ABUNDANT_ODD_NUMBERS.AWK

# converted from C

return(sum)

}

{{out}}

<pre>

=={{header|BASIC256}}==

{{trans|Visual Basic .NET}}

numimpar = 1

contar = 0

End While

End

=={{header|C}}==

#include <math.h>

return 0;

{{out}}

<pre>1: 945

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

using System.Collections.Generic;

using System.Linq;

static string Format(this (int n, int sum) pair) => $"{pair.n:N0} with sum {pair.sum:N0}";

{{out}}

<pre>

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

{{trans|Go}}

#include <iostream>

#include <numeric>

return 0;

{{out}}

<pre>The first 25 abundant odd numbers are:

=={{header|CLU}}==

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

x0: int := s / 2

break

end

{{out}}

<pre>1: 945 aliquot: 975

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

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

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

@type fixnum n sum-of-divisors

(until (< n sum-of-divisors))

{{out}}

=={{header|D}}==

{{trans|C++}}

int[] divisors(int n) {

writeln("\nThe first abundant odd number above one billion is:");

abundantOdd(cast(int)(1e9 + 1), 0, 1, true);

{{out}}

<pre>The first 25 abundant odd numbers are:

=={{header|Delphi}}==

{{trans|C}}

{$APPTYPE CONSOLE}

end.

{{out}}

<pre>1: 945

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

let n,g=aon 1L|>Seq.item 999 in printfn "\nThe 1000th abundant odd number is %d. The sum of it's divisors is %d" n g

let n,g=aon 1000000001L|>Seq.head in printfn "\nThe first abundant odd number greater than 1000000000 is %d. The sum of it's divisors is %d" n g

{{out}}

<pre>

=={{header|Factor}}==

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

IN: rosetta-code.abundant-odd-numbers

[ print show nl ] 2tri@ ;

{{out}}

<pre>

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

end program main

{{out}}

=={{header|FreeBASIC}}==

{{trans|Visual Basic .NET}}

Declare Function SumaDivisores(n As Integer) As Integer

Loop

End

{{out}}

<pre>

=={{header|Frink}}==

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

n = 3

println["$n: proper divisor sum " + sum[allFactors[n, 1, false]]]

{{out}}

<pre>

=={{header|FutureBasic}}==

{{trans|C}}

include "NSLog.incl"

HandleEvents

{{out}}

<pre>

=={{header|Go}}==

import (

fmt.Println("\nThe first abundant odd number above one billion is:")

abundantOdd(1e9+1, 0, 1, true)

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

static List<Integer> divisors(int n) {

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

abundantOdd((int) (1e9 + 1), 0, 1, true)

}

{{out}}

<pre>The first 25 abundant odd numbers are:

=={{header|Haskell}}==

divisorSum :: Integral a => a -> a

printAbundant $ oddAbundants 1 !! 1000

putStrLn "The first odd abundant number above 1000000000 is:"

{{out}}

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

import Data.Numbers.Primes

( [1 + billion, 3 + billion ..]

>>= abundantTuple

{{Out}}

<pre>First 25 abundant odd numbers with their divisor sums:

=={{header|Java}}==

import java.util.List;

}

{{out}}

<pre>

Composing reusable functions and generators:

{{Trans|Python}}

'use strict';

const main = () => {

// MAIN ---

return main();

{{Out}}

<pre>First 25 abundant odd numbers, with their divisor sums:

=={{header|jq}}==

# The factors, unsorted

def factors:

| (factors | add) as $sum

| select($sum > 2*.)

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

+ nth(999; abundant_odd_numbers))

| @tsv

{{out}}

<pre>

=={{header|Julia}}==

function propfact(n)

println("The first abundant odd number greater than one billion:")

oddabundantsfrom(1000000000, 1)

<pre>

First 25 abundant odd numbers:

=={{header|Kotlin}}==

{{trans|D}}

val divs = mutableListOf(1)

val divs2 = mutableListOf<Int>()

println("\nThe first abundant odd number above one billion is:")

abundantOdd((1e9 + 1).toInt(), 0, 1, true)

{{out}}

<pre>The first 25 abundant odd numbers are:

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

abundant_odd_numbers()

{{out}}

<pre>

=={{header|Lua}}==

function sumDivs (x)

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

for k, v in pairs(oddAbundants("First", 25)) do showResult(k, v) end

showResult("1000", oddAbundants("Nth", 1000))

{{out}}

<pre>1: the proper divisors of 945 sum to 975

=={{header|MAD}}==

INTERNAL FUNCTION(ND)

VECTOR VALUES HUGENO =

0 $25HFIRST ABOVE 1 BILLION IS ,I10,S1,7HDIVSUM ,I10*$

{{out}}

=={{header|Maple}}==

with(NumberTheory):

cat("First abundant odd number > 10^9 is ", number, ", its sum of divisors is ", SumOfDivisors(number), ", and its sum of proper divisors is ",divisorSum(number));

{{out}}<pre>

"First 25 abundant odd numbers"

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

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

res = {};

i += 2;

];

{{out}}

<pre>{{945,975},{1575,1649},{2205,2241},{2835,2973},{3465,4023},{4095,4641},{4725,5195},{5355,5877},{5775,6129},{5985,6495},{6435,6669},{6615,7065},{6825,7063},{7245,7731},{7425,7455},{7875,8349},{8085,8331},{8415,8433},{8505,8967},{8925,8931},{9135,9585},{9555,9597},{9765,10203},{10395,12645},{11025,11946}}

=={{header|Maxima}}==

while k < 25 do (

n: n+2,

),

return(l)

{{out}}

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

),

return([n,divsum(n)])

{{out}}

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

while n < 10^8 do (

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

),

return(l)

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

echo fmt"The sum of its proper divisors is {s}."

break

{{out}}

=={{header|Pascal}}==

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

program AbundantOddNumbers;

{$IFDEF FPC}

Inc(N, 2);

WriteLn('The first abundant odd number above one billion is: ',OutNum(N));

{{out}}

<pre>

{{trans|Raku}}

{{libheader|ntheory}}

use warnings;

use feature 'say';

say for odd_abundants(1, 25);

say "\nOne thousandth abundant odd number:\n", (odd_abundants(1, 1000))[999];

{{out}}

<pre style="height:20ex">First 25 abundant odd numbers:

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

<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;">"The first abundant odd number above one billion is:"</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">abundantOdd</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1e9</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #004600;">false</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

=={{header|PicoLisp}}==

(if (assoc Key (val Var))

(con @ (inc (cdr @)))

'****

1000000575

{{out}}

<pre>

=={{header|Processing}}==

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

int abundant = 0;

}

return sum;

{{out}}

<pre>First 25 abundant odd numbers:

=={{header|PureBasic}}==

{{trans|C}}

Input()

{{out}}

<pre> 1: 945 -&gt; 975 = 1+3+5+7+9+15+21+27+35+45+63+105+135+189+315

===Procedural===

{{trans|Visual Basic .NET}}

# Abundant odd numbers - Python

print ("\nFirst abundant odd number > 1 000 000 000:")

print (" ",oddNumber," proper divisor sum: ",dSum)

{{out}}

<pre>

===Functional===

from math import sqrt

if __name__ == '__main__':

{{Out}}

<pre>First 25 abundant odd numbers with their divisor sums:

=={{header|q}}==

sd:sum s@ / sum of proper divisors

abundant:{x<sd x}

Solution largely follows that for [[#J]], except the crucial definition of <code>s</code>.

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

q)1 sd\(not abundant@)(2+)/1000000000-1 / first abundant odd number above 1,000,000,000 and its divisors

References:

* [https://code.kx.com/q/ref/ Language Reference]

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

0 -1 [ 2 +

[ 2 + dup sigmasum

over 2 * > until ]

{{out}}

=={{header|R}}==

find_div_sum <- function(x){

# Get the first after 1e9

cat("First odd abundant after 1e9 is")

{{Out}}

=={{header|Racket}}==

(require math/number-theory

(for/list ([i (in-range 25)] [x (make-generator 0)]) x) ; Task 1

(for/last ([i (in-range 1000)] [x (make-generator 0)]) x) ; Task 2

{{out}}

{{works with|Rakudo|2019.03}}

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

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

put "\nOne thousandth abundant odd number:\n" ~ odd-abundants( :start-at(1) )[999] ~

{{out}}

<pre>First 25 abundant odd numbers:

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

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

end /*k*/ /* ___*/

if k*k==x then return s + k /*Was X a square? If so, add √ x */

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

<pre>

=={{header|Ring}}==

#Project: Anbundant odd numbers

see "" + index + ". " + string(n) + ": divisor sum: " +

see string(nArray[m]) + " = " + string(sum) + nl + nl

<pre>

=={{header|Ruby}}==

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

class Integer

puts "\n%d with sum %#d" % generator_odd_abundants.take(1000).last

puts "\n%d with sum %#d" % generator_odd_abundants(1_000_000_000).next

=={{header|Rust}}==

{{trans|Go}}

let mut divs = vec![1];

let mut divs2 = Vec::new();

println!("The first abundant odd number above one billion is:");

abundant_odd(1e9 as u64 + 1, 0, 1, true);

{{out}}

<pre>The first 25 abundant odd numbers are:

=={{header|Scala}}==

{{trans|D}}

object Abundant {

abundantOdd((1e9 + 1).intValue(), 0, 1, printOne = true)

}

{{out}}

<pre>The first 25 abundant odd numbers are:

=={{header|Sidef}}==

n.sigma > 2*n

}

with(odd_abundants(1e9).first) {|n|

printf(sep + fstr, '***', n, n.sigma-n)

{{out}}

<pre>

=={{header|Smalltalk}}==

[:nr |

|divs|

Transcript cr; showCR:'the 1000th odd abundant number is:'.

"from set of abdundant numbers>= 3, print 1000th to 1000th"

{{out}}

<pre>first 25 odd abundant numbers:

=={{header|Swift}}==

@inlinable

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

.first(where: { $1.0 })!

{{out}}

Loop

{{out}}

<pre> 1 945

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

Loop

End Sub

{{out}}

<pre>

=={{header|Vlang}}==

{{trans|go}}

mut divs := [i64(1)]

mut divs2 := []i64{}

println("\nThe first abundant odd number above one billion is:")

abundant_odd(1_000_000_001, 0, 1, true)

{{out}}

{{libheader|Wren-fmt}}

{{libheader|Wren-math}}

import "/math" for Int, Nums

System.print("\nThe first abundant odd number above one billion is:")

{{out}}

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

Assemble with tasm and tlink /t

.code

.486

int 29h

no30: ret

{{out}}

<pre>

=={{header|XPL0}}==

[Cnt:= 0;

Num:= 3; \find odd abundant numbers

Num:= Num+2;

];

{{out}}

=={{header|zkl}}==

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

n:=rn.value;

}

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

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

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

println("%6,d: %6,d = %s".fmt(n, ds.sum(0), ds.sort().concat(" + ")))

}

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

println("\nThe first abundant odd number above one billion is:");

{{out}}

<pre style="height:45ex; font-size:83%">