Sequence: smallest number greater than previous term with exactly n divisors: Difference between revisions

{{trans|Python}}

V divs = [1]

L(ii) 2 .< Int(n ^ 0.5) + 3

L(item) sequence(15)

{{out}}

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

Calculations on a real Atari 8-bit computer take quite long time. It is recommended to use an emulator capable with increasing speed of Atari CPU.

CARD i,count

PrintC(a)

OD

{{out}}

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

=={{header|Ada}}==

{{trans|Go}}

procedure Show_Sequence is

begin

Show (15);

{{out}}

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

{{trans|Go}} with a small optimisation.

PROC count divisors = ( INT n )INT:

OD

{{out}}

<pre>

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

{{Trans|Go}}...via Algol 68 and with a small optimisation.

integer max, next, i;

end;

write()

{{out}}

<pre>

=={{header|Arturo}}==

next: new 1

MAX: 15

inc 'i

]

{{out}}

=={{header|AutoHotkey}}==

{{trans|Go}}

next := 1, i := 1

while (next <= MAX)

count += (A_Index = n/A_Index) ? 1 : 2

return count

Outputs:<pre>The first 15 terms of the sequence are:

1, 2, 4, 6, 16, 18, 64, 66, 100, 112, 1024, 1035, 4096, 4288, 4624</pre>

=={{header|AWK}}==

# syntax: GAWK -f SEQUENCE_SMALLEST_NUMBER_GREATER_THAN_PREVIOUS_TERM_WITH_EXACTLY_N_DIVISORS.AWK

# converted from Kotlin

return(count)

}

{{out}}

<pre>

=={{header|C}}==

{{trans|Go}}

#define MAX 15

printf("\n");

return 0;

{{out}}

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

{{trans|C}}

#define MAX 15

cout << endl;

return 0;

{{out}}

===Alternative===

{{Trans|Pascal}}

#include <chrono>

i = (1 << (nxt - 1)) - 1; } i++; } while (nxt <= MAX);

printf("%d ms", (int)(duration<double>(steady_clock::now() - st).count() * 1000));

{{out}}

<pre>The first 32 anti-primes plus are: 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624 4632 65536 65572 262144 262192 263169 269312 4194304 4194306 4477456 4493312 4498641 4498752 268435456 268437200 1073741824 1073741830 223 ms</pre>

{{trans|Go}}

var count = 0

var i = 1

}

{{out}}

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

===First 28 are easy with a Naive implementation===

// Nigel Galloway: November 19th., 2017

let fN g=[1..(float>>sqrt>>int)g]|>List.fold(fun Σ n->if g%n>0 then Σ else if g/n=n then Σ+1 else Σ+2) 0

A069654 |> Seq.take 28|>Seq.iter(printf "%d "); printfn ""

{{out}}

<pre>

</pre>

=={{header|Factor}}==

: next ( n num -- n' num' )

[ 2 1 ] dip [ [ next ] keep ] replicate 2nip ;

{{out}}

<pre>

=={{header|FreeBASIC}}==

function divisors(byval n as ulongint) as uinteger

wend

print

{{out}}<pre> 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624</pre>

=={{header|Go}}==

import "fmt"

}

fmt.Println()

{{out}}

</pre>

=={{header|Haskell}}==

sequence_A069654 :: [(Int,Int)]

main :: IO ()

{{out}}

<pre>a( 1)= 1

=={{header|J}}==

sieve=: 3 :0

NB. sieve y returns a vector of y boxes.

(</.~ {."1) (,. i.@:#)tally

)

<pre>

=={{header|Java}}==

{{trans|C}}

static int count_divisors(int n) {

System.out.println();

}

{{out}}

{{works with|jq}}

'''Works with gojq, the Go implementation of jq'''

# The number of prime factors (as in prime factorization)

def numfactors:

"First 15 terms of OEIS sequence A069654: ",

{{out}}

<pre>

=={{header|Julia}}==

{{trans|Perl}}

function numfactors(n)

A06954(15)

<pre>

First 15 terms of OEIS sequence A069654:

=={{header|Kotlin}}==

{{trans|Go}}

const val MAX = 15

}

println()

{{output}}

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

highest = 0;

filter = {};

{r, res}

]

{{out}}

<pre>{1, 2, 4, 6, 16, 18, 64, 66, 100, 112, 1024, 1035, 4096, 4288, 4624}</pre>

=={{header|Nim}}==

const MAX = 15

inc next

inc i

{{out}}

<pre>

I think of next = 33 aka 11*3 with the solution 1031^2 * 2^10=1,088,472,064 with a big distance to next= 32 => 1073741830.<BR>

[https://tio.run/##fVRdb9owFH3Pr7gPk0hYWCG0e2hKJcbHhtQCapm0vSCZxAGvwaa2U1ZV/PWxazsQ2k7jIeR@n3t8HLH4RRPd2BCVkLyRbZL9fiPFUpI1dLlmU8nWVE3zQsXey4fRsD8YwnDa23kALx9uJ/0B9Gm@WbEdRgc39wMX6E6ns5/TAfQm4/vJzWAHZ2eQ2jyTNu6PhjuvUFRhsnpWhWa5CtdEr2IvEVxpdN92f0CnHcUeeFnBE80EhyXVffbEUipVj2ufX35nXLejoPyPPZzyOgcWz5Aak/ElcMA0AUwr2JitICOJFlKZMvJAMN6BKLpomr95q96eR/WLeRtWRIHf@tgK6n5kn218Ysq564yDvCciEbIxw8dC6BBX1eSOqlBSpeESDvgWdMk4ZqK7yDHQgZZZEJAeUwzGE8VoKbohkmjYMr0ShbatFVKAqdsVyymMhfYnaerzIIBUoPtL2RpwDezC4f7bne2OP8YT340MjIPy9DA1k2INXGwB2RU8fwaRpsCL9cJs5TayoNrxcbKvHqVvAsFVh78bjtzfCoQVVmQYDoISSAaWkQ40Qa@oK6mKAQ7EmZnNuHRKuqFEl4bb5pRgu5YLHXMsB2b628D/8QEUKPncgby6riBUDB7PtixxZB5gmabRCclIMe6cE2znxAYiMzosFYgJoyHaOKpVEVKpw73VUTnlmTmhzZqoqRHXn8/NCBZy@luHuBkK/r3WtpJpmnO/Nluh4plEKLUQb1dYA4LLNiwQxIM3HIiklzULf9bE8V@pnrHkoSeK46yDZsHMPBonJ@RgmMib28pKwnBhl9NxPf6pAwvaZ4ixFpyegak4Oiy3tseBT9vMCdnaPnSuYS2URkcEwdzWN1qBKVAiL7S7UiUsG4VrOA@gO@6D//ZzY2abb0NQYba4LA2gVjkc@zdaMX5UmJmDsCVdU65pCiTTVG6JTNV77Th@nP7GDgieUlyd4Mmr//pkGrMmMrVWhivs@cnb7/8kWU6Wat@YRH8B Try it online!]

{$IFDEF FPC}

{$MODE Delphi}

writeln;

writeln(GetTickCount64-T0,' ms');

{{out}}

<pre>The first 32 anti-primes plus are:

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use ntheory 'divisors';

print("$l "), $m = $l, last if $n == divisors($l);

}

{{out}}

=={{header|Phix}}==

Uses the optimisation trick from pascal, of n:=power(2,next-1) when next is a prime>4.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">limit</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">15</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">while</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 %d terms are: %v\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">limit</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

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

{{Trans|Go}} via Algol 68

/* CP/M BDOS SYSTEM CALL */

END;

{{out}}

<pre>

Note the use of text in column 81 onwards to hide the PL/I specifics from the PL/M compiler.

{{Trans|PL/M}}

sequence_100H: procedure options (main);

END;

{{out}}

<pre>

=={{header|Python}}==

def divisors(n):

divs = [1]

for item in sequence(15):

print(item)

<b>Output:</b>

1

2

4288

4624

=={{header|Quackery}}==

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

[ temp put

dip 2drop ] is task ( n --> [ )

{{out}}

=={{header|R}}==

divisorCount <- function(n) length(Filter(function(x) n %% x == 0, seq_len(n %/% 2))) + 1

A06954 <- function(terms)

out

}

{{out}}

<pre>[1] 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624</pre>

{{works with|Rakudo|2019.03}}

return 2 if x.is-prime;

+flat (1 .. x.sqrt.floor).map: -> \d {

put "First $limit terms of OEIS:A069654";

put (1..$limit).map: -> $n { my $ = $m = first { $n == .&div-count }, $m..Inf };

{{out}}

<pre>

Optimization was included when examining &nbsp; ''even'' &nbsp; or &nbsp; ''odd'' &nbsp; index numbers &nbsp; (determine how much to increment the &nbsp; '''do''' &nbsp; loop).

parse arg N . /*obtain optional argument from the CL.*/

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

else if k*k>x then leave /*only divide up to the √ x */

end /*k*/ /* [↑] this form of DO loop is faster.*/

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

<pre>

=={{header|Ring}}==

# Project : ANti-primes

next

return ansum

{{out}}

<pre>

=={{header|Ruby}}==

def num_divisors(n)

p seq.take(15)

{{out}}

<pre>[1, 2, 4, 6, 16, 18, 64, 66, 100, 112, 1024, 1035, 4096, 4288, 4624]

=={{header|Sidef}}==

from..Inf -> first_by { .sigma0 == n }

}

with (1) { |from|

say 15.of { from = n_divisors(_+1, from) }

{{out}}

<pre>

=={{header|Swift}}==

Includes an optimization borrowed from the Pascal example above.

func divisorCount(number: Int) -> Int {

var n = number

n += 1

}

{{out}}

{{trans|Phix}}

{{libheader|Wren-math}}

var limit = 24

}

System.print("The first %(limit) terms are:")

{{out}}

=={{header|XPL0}}==

int N, D, C;

[C:= 0;

An:= An+1;

];

{{out}}

=={{header|zkl}}==

println("The first %d anti-primes plus are:".fmt(n));

(1).walker(*).tweak(

fcn(n,rn){ if(rn.value==countDivisors(n)){ rn.inc(); n } else Void.Skip }.fp1(Ref(1)))

{{out}}

<pre>