Rosetta Code

Frobenius numbers: Difference between revisions

Page Discussion

Frobenius numbers (view source)

Revision as of 13:42, 27 August 2022

1,164 bytes added ,  1 year ago
m
syntax highlighting fixup automation
m (syntax highlighting fixup automation)
Line 24:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">F isPrime(v)
I v <= 1
R 0B
Line 53:
L.break
print(n‘ => ’f)
pn = i</langsyntaxhighlight>
 
{{out}}
Line 86:
=={{header|Action!}}==
{{libheader|Action! Sieve of Eratosthenes}}
<langsyntaxhighlight Actionlang="action!">INCLUDE "H6:SIEVE.ACT"
 
INT FUNC NextPrime(INT p BYTE ARRAY primes)
Line 114:
FI
OD
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Frobenius_numbers.png Screenshot from Atari 8-bit computer]
Line 122:
 
=={{header|ALGOL 68}}==
<langsyntaxhighlight lang="algol68">BEGIN # find some Frobenius Numbers: #
# Frobenius(n) = ( prime(n) * prime(n+1) ) - prime(n) - prime(n+1) #
# reurns a list of primes up to n #
Line 150:
print( ( " ", whole( frobenius number, 0 ) ) )
OD
END</langsyntaxhighlight>
{{out}}
<pre>
Line 158:
=={{header|APL}}==
{{works with|Dyalog APL}}
<langsyntaxhighlight APLlang="apl">(¯1↓(⊢×1∘⌽)-⊢+1∘⌽)∘((⊢(/⍨)(~⊢∊∘.×⍨))1↓⍳)∘(⌊1+*∘.5) 10000</langsyntaxhighlight>
{{out}}
<pre>1 7 23 59 119 191 287 395 615 839 1079 1439 1679 1931 2391 3015 3479 3959 4619 5039 5615 6395 7215 8447 9599</pre>
 
=={{header|AppleScript}}==
<langsyntaxhighlight lang="applescript">on isPrime(n)
if (n < 4) then return (n > 1)
if ((n mod 2 is 0) or (n mod 3 is 0)) then return false
Line 193:
end Frobenii
 
Frobenii(9999)</langsyntaxhighlight>
 
{{output}}
<langsyntaxhighlight lang="applescript">{1, 7, 23, 59, 119, 191, 287, 395, 615, 839, 1079, 1439, 1679, 1931, 2391, 3015, 3479, 3959, 4619, 5039, 5615, 6395, 7215, 8447, 9599}</langsyntaxhighlight>
 
=={{header|Arturo}}==
<langsyntaxhighlight lang="rebol">primes: select 0..10000 => prime?
frobenius: function [n] -> sub sub primes\[n] * primes\[n+1] primes\[n] primes\[n+1]
 
Line 211:
 
loop split.every:10 chop lst 'a ->
print map a => [pad to :string & 5]</langsyntaxhighlight>
 
{{out}}
Line 220:
 
=={{header|AutoHotkey}}==
<langsyntaxhighlight AutoHotkeylang="autohotkey">n := 0, i := 1, pn := 2
loop {
if isprime(i+=2) {
Line 245:
return false
return true
}</langsyntaxhighlight>
{{out}}
<pre> 1 7 23 59 119
Line 254:
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f FROBENIUS_NUMBERS.AWK
# converted from FreeBASIC
Line 283:
return(1)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 293:
 
=={{header|BASIC}}==
<langsyntaxhighlight lang="basic">10 DEFINT A-Z
20 LM = 10000
30 M = SQR(LM)+1
Line 305:
110 FOR N=0 TO C-2
120 PRINT P(N)*P(N+1)-P(N)-P(N+1),
130 NEXT N</langsyntaxhighlight>
{{out}}
<pre> 1 7 23 59 119
Line 315:
 
=={{header|BASIC256}}==
<syntaxhighlight lang="basic256">
<lang BASIC256>
n = 0
lim = 10000
Line 334:
next i
end
</syntaxhighlight>
</lang>
 
 
=={{header|BCPL}}==
<langsyntaxhighlight lang="bcpl">get "libhdr"
manifest $( limit = 10000 $)
 
Line 391:
writef("%N*N", frob(primes, n))
freevec(primes)
$)</langsyntaxhighlight>
{{out}}
<pre>1
Line 420:
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
#include <math.h>
Line 457:
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>1
Line 487:
=={{header|C sharp|C#}}==
Asterisks mark the non-primes among the numbers.
<langsyntaxhighlight lang="csharp">using System.Collections.Generic; using System.Linq; using static System.Console; using static System.Math;
 
class Program {
Line 509:
if (!flags[j]) { yield return j;
for (int k = sq, i = j << 1; k <= lim; k += i) flags[k] = true; }
for (; j <= lim; j += 2) if (!flags[j]) yield return j; } }</langsyntaxhighlight>
 
{{out}}
Line 534:
=={{header|C++}}==
{{libheader|Primesieve}}
<langsyntaxhighlight lang="cpp">#include <cstdint>
#include <iomanip>
#include <iostream>
Line 573:
}
std::cout << '\n';
}</langsyntaxhighlight>
 
{{out}}
Line 598:
 
=={{header|Cowgol}}==
<langsyntaxhighlight lang="cowgol">include "cowgol.coh";
 
const LIMIT := 10000;
Line 652:
print_nl();
n := n + 1;
end loop;</langsyntaxhighlight>
{{out}}
<pre>1
Line 682:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
<langsyntaxhighlight lang="factor">USING: io kernel math math.primes prettyprint ;
 
"Frobenius numbers < 10,000:" print
Line 688:
[ nip dup next-prime ] [ * ] [ [ - ] dip - ] 2tri
dup 10,000 <
] [ . ] while 3drop</langsyntaxhighlight>
{{out}}
<pre style="height:14em">
Line 720:
 
=={{header|Fermat}}==
<langsyntaxhighlight lang="fermat">Function Frobenius(n)=Prime(n)*Prime(n+1)-Prime(n)-Prime(n+1).
for n = 1 to 25 do !!Frobenius(n) od</langsyntaxhighlight>
{{out}}
<pre>
Line 752:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">#include "isprime.bas"
 
dim as integer pn=2, n=0, f
Line 763:
pn = i
end if
next i</langsyntaxhighlight>
{{out}}
<pre>
Line 796:
{{trans|Wren}}
{{libheader|Go-rcu}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 821:
}
fmt.Printf("\n\n%d such numbers found.\n", len(frobenius))
}</langsyntaxhighlight>
 
{{out}}
Line 834:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">primes = 2 : sieve [3,5..]
where sieve (x:xs) = x : sieve (filter (\y -> y `mod` x /= 0) xs)
 
frobenius = zipWith (\a b -> a*b - a - b) primes (tail primes)</langsyntaxhighlight>
 
<pre>λ> takeWhile (< 10000) frobenius
Line 843:
 
=={{header|J}}==
<langsyntaxhighlight Jlang="j">frob =: (*&p: - +&p:) >:
echo frob i. 25</langsyntaxhighlight>
 
(Note that <code>frob</code> counts prime numbers starting from 0 (which gives 2), so for some contexts the function to calculate frobenius numbers would be <code>frob@<:</code>.)
Line 853:
=={{header|Java}}==
Uses the PrimeGenerator class from [[Extensible prime generator#Java]].
<langsyntaxhighlight lang="java">public class Frobenius {
public static void main(String[] args) {
final int limit = 1000000;
Line 888:
return true;
}
}</langsyntaxhighlight>
 
{{out}}
Line 921:
 
See e.g. [[Erd%C5%91s-primes#jq]] for a suitable implementation of `is_prime`.
<langsyntaxhighlight lang="jq"># Generate a stream of Frobenius numbers up to an including `.`;
# specify `null` or `infinite` to generate an unbounded stream.
def frobenius:
Line 934:
.frob);
 
9999 | frobenius</langsyntaxhighlight>
{{out}}
<pre>
Line 965:
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">using Primes
 
const primeslt10k = primes(10000)
Line 989:
 
testfrobenius()
</langsyntaxhighlight>{{out}}
<pre>
Frobenius numbers less than 1,000,000 (an asterisk marks the prime ones).
Line 1,012:
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">ClearAll[fn]
fn[n_] := Prime[n] Prime[n + 1] - Prime[n] - Prime[n + 1]
a = -1;
Line 1,022:
If[a < 10^4, AppendTo[res, a]]
]
res</langsyntaxhighlight>
{{out}}
<pre>{1,7,23,59,119,191,287,395,615,839,1079,1439,1679,1931,2391,3015,3479,3959,4619,5039,5615,6395,7215,8447,9599}</pre>
Line 1,028:
=={{header|Nim}}==
As I like iterators, I used one for (odd) primes and one for Frobenius numbers. Of course, there are other ways to proceed.
<langsyntaxhighlight Nimlang="nim">import sequtils, strutils
 
func isOddPrime(n: Positive): bool =
Line 1,060:
var result = toSeq(frobenius(10_000))
echo "Found $1 Frobenius numbers less than $2:".format(result.len, N)
echo result.join(" ")</langsyntaxhighlight>
 
{{out}}
Line 1,068:
=={{header|Perl}}==
{{libheader|ntheory}}
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use feature 'say';
Line 1,081:
# process a list with a 2-wide sliding window
my $limit = 10_000;
say "\n" . join ' ', grep { $_ < $limit } slide { $a * $b - $a - $b } @{primes($limit)};</langsyntaxhighlight>
{{out}}
<pre>25 matching numbers:
Line 1,089:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">for</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">4</span> <span style="color: #008080;">to</span> <span style="color: #000000;">6</span> <span style="color: #008080;">by</span> <span style="color: #000000;">2</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">lim</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">),</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span>
Line 1,105:
<span style="color: #0000FF;">{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">frob</span><span style="color: #0000FF;">),</span><span style="color: #000000;">lim</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">frob</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">),</span><span style="color: #008000;">", "</span><span style="color: #0000FF;">)})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 1,114:
 
=={{header|Python}}==
<langsyntaxhighlight lang="python">
#!/usr/bin/python
 
Line 1,147:
print (n, ' => ', f)
pn = i
</syntaxhighlight>
</lang>
 
=={{header|PL/M}}==
<langsyntaxhighlight lang="plm">100H:
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;
Line 1,223:
END;
CALL EXIT;
EOF</langsyntaxhighlight>
{{out}}
<pre>1
Line 1,253:
 
=={{header|PureBasic}}==
<syntaxhighlight lang="purebasic">
<lang PureBasic>
Procedure isPrime(v.i)
If v < = 1 : ProcedureReturn #False
Line 1,290:
CloseConsole()
End
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,322:
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" perl6line>say "{+$_} matching numbers\n{.batch(10)».fmt('%4d').join: "\n"}\n"
given (^1000).grep( *.is-prime ).rotor(2 => -1)
.map( { (.[0] * .[1] - .[0] - .[1]) } ).grep(* < 10000);</langsyntaxhighlight>
{{out}}
<pre>25 matching numbers
Line 1,332:
 
=={{header|REXX}}==
<langsyntaxhighlight lang="rexx">/*REXX program finds Frobenius numbers where the numbers are less than some number N. */
parse arg hi cols . /*obtain optional argument from the CL.*/
if hi=='' | hi=="," then hi= 10000 /* " " " " " " */
Line 1,370:
end /*k*/ /* [↑] only process numbers ≤ √ J */
#= #+1; @.#= j; sq.#= j*j /*bump # Ps; assign next P; P squared*/
end /*j*/; return</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 1,384:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">load "stdlib.ring" # for isprime() function
? "working..." + nl + "Frobenius numbers are:"
Line 1,407:
s = string(x) l = len(s)
if l > y y = l ok
return substr(" ", 11 - y + l) + s</langsyntaxhighlight>
{{out}}
<pre>working...
Line 1,422:
 
=={{header|Rust}}==
<langsyntaxhighlight lang="rust">// [dependencies]
// primal = "0.3"
 
Line 1,452:
}
println!();
}</langsyntaxhighlight>
 
{{out}}
Line 1,477:
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">func frobenius_number(n) {
prime(n) * prime(n+1) - prime(n) - prime(n+1)
}
Line 1,487:
take(n)
}
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,497:
{{libheader|Wren-seq}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight lang="ecmascript">import "/math" for Int
import "/seq" for Lst
import "/fmt" for Fmt
Line 1,510:
System.print("Frobenius numbers under 10,000:")
for (chunk in Lst.chunks(frobenius, 9)) Fmt.print("$,5d", chunk)
System.print("\n%(frobenius.count) such numbers found.")</langsyntaxhighlight>
 
{{out}}
Line 1,523:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">func IsPrime(N); \Return 'true' if N is a prime number
int N, I;
[if N <= 1 then return false;
Line 1,548:
Text(0, " Frobenius numbers found below 10,000.
");
]</langsyntaxhighlight>
 
{{out}}
Line 1,560:
=={{header|Yabasic}}==
{{trans|PureBasic}}
<langsyntaxhighlight lang="yabasic">
sub isPrime(v)
if v < 2 then return False : fi
Line 1,584:
next i
end
</syntaxhighlight>
</lang>
{{out}}
<pre>
Thundergnat
10,327

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/327611"