Frobenius numbers: Difference between revisions

{{trans|Python}}

I v <= 1

R 0B

L.break

print(n‘ => ’f)

{{out}}

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

{{libheader|Action! Sieve of Eratosthenes}}

INT FUNC NextPrime(INT p BYTE ARRAY primes)

FI

OD

{{out}}

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

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

# Frobenius(n) = ( prime(n) * prime(n+1) ) - prime(n) - prime(n+1) #

# reurns a list of primes up to n #

print( ( " ", whole( frobenius number, 0 ) ) )

OD

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

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

if (n < 4) then return (n > 1)

if ((n mod 2 is 0) or (n mod 3 is 0)) then return false

end Frobenii

{{output}}

=={{header|Arturo}}==

frobenius: function [n] -> sub sub primes\[n] * primes\[n+1] primes\[n] primes\[n+1]

loop split.every:10 chop lst 'a ->

{{out}}

=={{header|AutoHotkey}}==

loop {

if isprime(i+=2) {

return false

return true

{{out}}

<pre> 1 7 23 59 119

=={{header|AWK}}==

# syntax: GAWK -f FROBENIUS_NUMBERS.AWK

# converted from FreeBASIC

return(1)

}

{{out}}

<pre>

=={{header|BASIC}}==

20 LM = 10000

30 M = SQR(LM)+1

110 FOR N=0 TO C-2

120 PRINT P(N)*P(N+1)-P(N)-P(N+1),

{{out}}

<pre> 1 7 23 59 119

=={{header|BASIC256}}==

n = 0

lim = 10000

next i

end

=={{header|BCPL}}==

manifest $( limit = 10000 $)

writef("%N*N", frob(primes, n))

freevec(primes)

{{out}}

<pre>1

=={{header|C}}==

#include <stdlib.h>

#include <math.h>

return 0;

{{out}}

<pre>1

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

Asterisks mark the non-primes among the numbers.

class Program {

if (!flags[j]) { yield return j;

for (int k = sq, i = j << 1; k <= lim; k += i) flags[k] = true; }

{{out}}

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

{{libheader|Primesieve}}

#include <iomanip>

#include <iostream>

}

std::cout << '\n';

{{out}}

=={{header|Cowgol}}==

const LIMIT := 10000;

print_nl();

n := n + 1;

{{out}}

<pre>1

=={{header|Factor}}==

{{works with|Factor|0.99 2021-02-05}}

"Frobenius numbers < 10,000:" print

[ nip dup next-prime ] [ * ] [ [ - ] dip - ] 2tri

dup 10,000 <

{{out}}

<pre style="height:14em">

=={{header|Fermat}}==

{{out}}

<pre>

=={{header|FreeBASIC}}==

dim as integer pn=2, n=0, f

pn = i

end if

{{out}}

<pre>

{{trans|Wren}}

{{libheader|Go-rcu}}

import (

}

fmt.Printf("\n\n%d such numbers found.\n", len(frobenius))

{{out}}

=={{header|Haskell}}==

where sieve (x:xs) = x : sieve (filter (\y -> y `mod` x /= 0) xs)

<pre>λ> takeWhile (< 10000) frobenius

=={{header|J}}==

(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>.)

=={{header|Java}}==

Uses the PrimeGenerator class from [[Extensible prime generator#Java]].

public static void main(String[] args) {

final int limit = 1000000;

return true;

}

{{out}}

See e.g. [[Erd%C5%91s-primes#jq]] for a suitable implementation of `is_prime`.

# specify `null` or `infinite` to generate an unbounded stream.

def frobenius:

.frob);

{{out}}

<pre>

=={{header|Julia}}==

const primeslt10k = primes(10000)

testfrobenius()

<pre>

Frobenius numbers less than 1,000,000 (an asterisk marks the prime ones).

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

fn[n_] := Prime[n] Prime[n + 1] - Prime[n] - Prime[n + 1]

a = -1;

If[a < 10^4, AppendTo[res, a]]

]

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

As I like iterators, I used one for (odd) primes and one for Frobenius numbers. Of course, there are other ways to proceed.

func isOddPrime(n: Positive): bool =

var result = toSeq(frobenius(10_000))

echo "Found $1 Frobenius numbers less than $2:".format(result.len, N)

{{out}}

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use feature 'say';

# process a list with a 2-wide sliding window

my $limit = 10_000;

{{out}}

<pre>25 matching numbers:

=={{header|Phix}}==

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

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

{{out}}

<pre>

=={{header|Python}}==

#!/usr/bin/python

print (n, ' => ', f)

pn = i

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

BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;

EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;

END;

CALL EXIT;

{{out}}

<pre>1

=={{header|PureBasic}}==

Procedure isPrime(v.i)

If v < = 1 : ProcedureReturn #False

CloseConsole()

End

{{out}}

<pre>

=={{header|Raku}}==

given (^1000).grep( *.is-prime ).rotor(2 => -1)

{{out}}

<pre>25 matching numbers

=={{header|REXX}}==

parse arg hi cols . /*obtain optional argument from the CL.*/

if hi=='' | hi=="," then hi= 10000 /* " " " " " " */

end /*k*/ /* [↑] only process numbers ≤ √ J */

#= #+1; @.#= j; sq.#= j*j /*bump # Ps; assign next P; P squared*/

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

<pre>

=={{header|Ring}}==

? "working..." + nl + "Frobenius numbers are:"

s = string(x) l = len(s)

if l > y y = l ok

{{out}}

<pre>working...

=={{header|Rust}}==

// primal = "0.3"

}

println!();

{{out}}

=={{header|Sidef}}==

prime(n) * prime(n+1) - prime(n) - prime(n+1)

}

take(n)

}

{{out}}

<pre>

{{libheader|Wren-seq}}

{{libheader|Wren-fmt}}

import "/seq" for Lst

import "/fmt" for Fmt

System.print("Frobenius numbers under 10,000:")

for (chunk in Lst.chunks(frobenius, 9)) Fmt.print("$,5d", chunk)

{{out}}

=={{header|XPL0}}==

int N, I;

[if N <= 1 then return false;

Text(0, " Frobenius numbers found below 10,000.

");

{{out}}

=={{header|Yabasic}}==

{{trans|PureBasic}}

sub isPrime(v)

if v < 2 then return False : fi

next i

end

{{out}}

<pre>