Jump to content

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

Sequence: smallest number greater than previous term with exactly n divisors (view source)

Revision as of 13:51, 28 August 2022

1,251 bytes added ,  1 year ago
m
syntax highlighting fixup automation
(Added Arturo implementation)
m (syntax highlighting fixup automation)
Line 22:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">F divisors(n)
V divs = [1]
L(ii) 2 .< Int(n ^ 0.5) + 3
Line 49:
 
L(item) sequence(15)
print(item)</langsyntaxhighlight>
 
{{out}}
Line 72:
=={{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.
<langsyntaxhighlight Actionlang="action!">CARD FUNC CountDivisors(CARD a)
CARD i,count
 
Line 105:
PrintC(a)
OD
RETURN</langsyntaxhighlight>
{{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]
Line 114:
=={{header|Ada}}==
{{trans|Go}}
<langsyntaxhighlight Adalang="ada">with Ada.Text_IO;
 
procedure Show_Sequence is
Line 153:
begin
Show (15);
end Show_Sequence;</langsyntaxhighlight>
 
{{out}}
Line 161:
=={{header|ALGOL 68}}==
{{trans|Go}} with a small optimisation.
<langsyntaxhighlight lang="algol68">BEGIN
 
PROC count divisors = ( INT n )INT:
Line 183:
OD
 
END</langsyntaxhighlight>
{{out}}
<pre>
Line 191:
=={{header|ALGOL W}}==
{{Trans|Go}}...via Algol 68 and with a small optimisation.
<langsyntaxhighlight lang="pascal">begin
integer max, next, i;
 
Line 219:
end;
write()
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 227:
=={{header|Arturo}}==
 
<langsyntaxhighlight lang="rebol">i: new 0
next: new 1
MAX: 15
Line 237:
inc 'i
]
print ""</langsyntaxhighlight>
 
{{out}}
Line 245:
=={{header|AutoHotkey}}==
{{trans|Go}}
<langsyntaxhighlight AutoHotkeylang="autohotkey">MAX := 15
next := 1, i := 1
while (next <= MAX)
Line 258:
count += (A_Index = n/A_Index) ? 1 : 2
return count
}</langsyntaxhighlight>
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}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f SEQUENCE_SMALLEST_NUMBER_GREATER_THAN_PREVIOUS_TERM_WITH_EXACTLY_N_DIVISORS.AWK
# converted from Kotlin
Line 287:
return(count)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 295:
=={{header|C}}==
{{trans|Go}}
<langsyntaxhighlight lang="c">#include <stdio.h>
 
#define MAX 15
Line 323:
printf("\n");
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 333:
=={{header|C++}}==
{{trans|C}}
<langsyntaxhighlight lang="cpp">#include <iostream>
 
#define MAX 15
Line 362:
cout << endl;
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 371:
===Alternative===
{{Trans|Pascal}}
More terms and quicker than the straightforward C version above. [https://tio.run/##bVJNb9NAFLz7V0yLGu1ihzopJ38EIbgiJMSBG3J3N84KZ@1417QI5a8T3tuQNqm42W/emxnPWA3DvFXqcHhlneombVApH7TtV8nZZDP2jibJ5K1r4Zqt8UOjDGizKI5omSSqdz7AuoBP77@hxt2yTJBMztvWGR2B1oSP9qfVZvQfXBAXmJP4nQAXM800GXYZ9BfjM4zG02RBvHjY2M5AXAmHGRaSjuGwWjHKa2laYv@8JjReQ0tUddTBjmgcbqFL2DWI44a1auQMshbhOcsAuj@N0pqZSzqssSuJ47Zmgv1J5IzleIpomM74nBc1vyz5aTRhGh1RXZFjvIuLVUWPxVFjnyQcwLaxTrCni1hsBvcYMlCWFCNrDSPN1@L668ZgbUfq4UajccHOCaG6MHSTRzOaAtcZ9xMdNlPoqUT6HB9Mo399V12vfhSF6x@EpGQ4pMcQE48xxI/ivMRRmZAXjVoqoj5eseuTLTJDsvYplsiRpry2wluJ2QziBRNhkWop5b8jRENiwTkxjHnsfc7u9rCx8acqCKauTx965mPryYmgVyn0NDbB9q7S/XTfmZX4TwpE74N8o/qJPEn6iRZ5nksi3R8Of9S6a1p/mH@@@ws Try It Online!]<langsyntaxhighlight lang="cpp">#include <cstdio>
#include <chrono>
 
Line 392:
i = (1 << (nxt - 1)) - 1; } i++; } while (nxt <= MAX);
printf("%d ms", (int)(duration<double>(steady_clock::now() - st).count() * 1000));
}</langsyntaxhighlight>
{{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>
Line 400:
{{trans|Go}}
 
<langsyntaxhighlight lang="dyalect">func countDivisors(n) {
var count = 0
var i = 1
Line 427:
}
 
print()</langsyntaxhighlight>
 
{{out}}
Line 436:
=={{header|F_Sharp|F#}}==
===First 28 are easy with a Naive implementation===
<langsyntaxhighlight lang="fsharp">
// 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
Line 442:
 
A069654 |> Seq.take 28|>Seq.iter(printf "%d "); printfn ""
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 448:
</pre>
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">USING: io kernel math math.primes.factors prettyprint sequences ;
 
: next ( n num -- n' num' )
Line 456:
[ 2 1 ] dip [ [ next ] keep ] replicate 2nip ;
 
"The first 15 terms of the sequence are:" print 15 A069654 .</langsyntaxhighlight>
{{out}}
<pre>
Line 464:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">#define UPTO 15
 
function divisors(byval n as ulongint) as uinteger
Line 489:
wend
print
end</langsyntaxhighlight>
{{out}}<pre> 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624</pre>
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 521:
}
fmt.Println()
}</langsyntaxhighlight>
 
{{out}}
Line 529:
</pre>
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Text.Printf (printf)
 
sequence_A069654 :: [(Int,Int)]
Line 540:
 
main :: IO ()
main = mapM_ (uncurry $ printf "a(%2d)=%5d\n") $ take 15 sequence_A069654</langsyntaxhighlight>
{{out}}
<pre>a( 1)= 1
Line 560:
 
=={{header|J}}==
<syntaxhighlight lang="j">
<lang j>
sieve=: 3 :0
NB. sieve y returns a vector of y boxes.
Line 578:
(</.~ {."1) (,. i.@:#)tally
)
</syntaxhighlight>
</lang>
 
<pre>
Line 706:
=={{header|Java}}==
{{trans|C}}
<langsyntaxhighlight lang="java">public class AntiPrimesPlus {
 
static int count_divisors(int n) {
Line 732:
System.out.println();
}
}</langsyntaxhighlight>
 
{{out}}
Line 744:
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<syntaxhighlight lang="jq">
<lang jq>
# The number of prime factors (as in prime factorization)
def numfactors:
Line 764:
 
"First 15 terms of OEIS sequence A069654: ",
[limit(15; A06954)]</langsyntaxhighlight>
{{out}}
<pre>
Line 774:
=={{header|Julia}}==
{{trans|Perl}}
<langsyntaxhighlight lang="julia">using Primes
 
function numfactors(n)
Line 800:
 
A06954(15)
</langsyntaxhighlight>{{out}}
<pre>
First 15 terms of OEIS sequence A069654:
Line 808:
=={{header|Kotlin}}==
{{trans|Go}}
<langsyntaxhighlight lang="scala">// Version 1.3.21
 
const val MAX = 15
Line 836:
}
println()
}</langsyntaxhighlight>
 
{{output}}
Line 845:
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">res = {#, DivisorSigma[0, #]} & /@ Range[100000];
highest = 0;
filter = {};
Line 856:
{r, res}
]
Take[filter, 15]</langsyntaxhighlight>
{{out}}
<pre>{1, 2, 4, 6, 16, 18, 64, 66, 100, 112, 1024, 1035, 4096, 4288, 4624}</pre>
 
=={{header|Nim}}==
<langsyntaxhighlight lang="nim">import strformat
 
const MAX = 15
Line 884:
inc next
inc i
write(stdout, "\n")</langsyntaxhighlight>
{{out}}
<pre>
Line 897:
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!]
<langsyntaxhighlight lang="pascal">program AntiPrimesPlus;
{$IFDEF FPC}
{$MODE Delphi}
Line 967:
writeln;
writeln(GetTickCount64-T0,' ms');
end.</langsyntaxhighlight>
{{out}}
<pre>The first 32 anti-primes plus are:
Line 975:
=={{header|Perl}}==
{{libheader|ntheory}}
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use ntheory 'divisors';
Line 986:
print("$l "), $m = $l, last if $n == divisors($l);
}
}</langsyntaxhighlight>
{{out}}
 
Line 994:
=={{header|Phix}}==
Uses the optimisation trick from pascal, of n:=power(2,next-1) when next is a prime>4.
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<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>
Line 1,012:
<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>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 1,032:
=={{header|PL/M}}==
{{Trans|Go}} via Algol 68
<langsyntaxhighlight lang="pli">100H: /* FIND THE SMALLEST NUMBER > THE PREVIOUS ONE WITH EXACTLY N DIVISORS */
 
/* CP/M BDOS SYSTEM CALL */
Line 1,082:
END;
 
EOF</langsyntaxhighlight>
{{out}}
<pre>
Line 1,097:
Note the use of text in column 81 onwards to hide the PL/I specifics from the PL/M compiler.
{{Trans|PL/M}}
<langsyntaxhighlight lang="pli"> /* FIND THE SMALLEST NUMBER > THE PREVIOUS ONE WITH EXACTLY N DIVISORS */
 
sequence_100H: procedure options (main);
Line 1,177:
END;
 
EOF: end sequence_100H;</langsyntaxhighlight>
{{out}}
<pre>
Line 1,184:
 
=={{header|Python}}==
<syntaxhighlight lang="python">
<lang Python>
def divisors(n):
divs = [1]
Line 1,215:
for item in sequence(15):
print(item)
</syntaxhighlight>
</lang>
<b>Output:</b>
<syntaxhighlight lang="python">
<lang Python>
1
2
Line 1,233:
4288
4624
</syntaxhighlight>
</lang>
 
=={{header|Quackery}}==
Line 1,239:
<code>factors</code> is defined at [[Factors of an integer#Quackery]].
 
<langsyntaxhighlight Quackerylang="quackery"> [ stack ] is terms ( --> s )
 
[ temp put
Line 1,258:
dip 2drop ] is task ( n --> [ )
 
15 task echo</langsyntaxhighlight>
 
{{out}}
Line 1,265:
 
=={{header|R}}==
<langsyntaxhighlight lang="rsplus">#Need to add 1 to account for skipping n. Not the most efficient way to count divisors, but quite clear.
divisorCount <- function(n) length(Filter(function(x) n %% x == 0, seq_len(n %/% 2))) + 1
A06954 <- function(terms)
Line 1,278:
out
}
print(A06954(15))</langsyntaxhighlight>
{{out}}
<pre>[1] 1 2 4 6 16 18 64 66 100 112 1024 1035 4096 4288 4624</pre>
Line 1,286:
{{works with|Rakudo|2019.03}}
 
<syntaxhighlight lang="raku" perl6line>sub div-count (\x) {
return 2 if x.is-prime;
+flat (1 .. x.sqrt.floor).map: -> \d {
Line 1,298:
put "First $limit terms of OEIS:A069654";
put (1..$limit).map: -> $n { my $ = $m = first { $n == .&div-count }, $m..Inf };
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,311:
 
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).
<langsyntaxhighlight lang="rexx">/*REXX program finds and displays N numbers of the "anti─primes plus" sequence. */
parse arg N . /*obtain optional argument from the CL.*/
if N=='' | N=="," then N= 15 /*Not specified? Then use the default.*/
Line 1,344:
else if k*k>x then leave /*only divide up to the √ x */
end /*k*/ /* [↑] this form of DO loop is faster.*/
return # + 1 /*bump "proper divisors" to "divisors".*/</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default input:}}
<pre>
Line 1,366:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
# Project : ANti-primes
 
Line 1,404:
next
return ansum
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,418:
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">require 'prime'
def num_divisors(n)
Line 1,435:
 
p seq.take(15)
</syntaxhighlight>
</lang>
{{out}}
<pre>[1, 2, 4, 6, 16, 18, 64, 66, 100, 112, 1024, 1035, 4096, 4288, 4624]
Line 1,441:
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">func n_divisors(n, from=1) {
from..Inf -> first_by { .sigma0 == n }
}
Line 1,447:
with (1) { |from|
say 15.of { from = n_divisors(_+1, from) }
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,455:
=={{header|Swift}}==
Includes an optimization borrowed from the Pascal example above.
<langsyntaxhighlight lang="swift">// See https://en.wikipedia.org/wiki/Divisor_function
func divisorCount(number: Int) -> Int {
var n = number
Line 1,495:
n += 1
}
print()</langsyntaxhighlight>
 
{{out}}
Line 1,505:
{{trans|Phix}}
{{libheader|Wren-math}}
<langsyntaxhighlight lang="ecmascript">import "/math" for Int
 
var limit = 24
Line 1,521:
}
System.print("The first %(limit) terms are:")
System.print(res)</langsyntaxhighlight>
 
{{out}}
Line 1,530:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">func Divs(N); \Count divisors of N
int N, D, C;
[C:= 0;
Line 1,551:
An:= An+1;
];
]</langsyntaxhighlight>
 
{{out}}
Line 1,559:
 
=={{header|zkl}}==
<langsyntaxhighlight lang="zkl">fcn countDivisors(n)
{ [1..(n).toFloat().sqrt()] .reduce('wrap(s,i){ s + (if(0==n%i) 1 + (i!=n/i)) },0) }</langsyntaxhighlight>
<langsyntaxhighlight lang="zkl">n:=15;
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)))
.walk(n).concat(" ").println();</langsyntaxhighlight>
{{out}}
<pre>
Thundergnat
10,333

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/328354"
Cookies help us deliver our services. By using our services, you agree to our use of cookies.
More information