Jacobsthal numbers: Difference between revisions

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

{{libheader|ALGOL 68-primes}}

INT max jacobsthal = 29; # highest Jacobsthal number we will find #

INT max oblong = 20; # highest Jacobsthal oblong number we will find #

FI

OD

{{out}}

<pre>

=={{header|AppleScript}}==

===Procedural===

-- variant: text containing "Lucas", "oblong", or "prime" — or none of these.

-- n: length of output sequence required.

 

task()

 

{{output}}

0 1 1 3 5 11 21 43 85 171

341 683 1365 2731 5461 10923 21845 43691 87381 174763

First 11 Jacobsthal Primes:

3 5 11 43 683 2731

 

===Functional===

 

-- e.g. take(10, jacobsthal())

end |λ|

end script

{{Out}}

<pre>30 first terms of the Jacobsthal sequence:

=={{header|Arturo}}==

 

JL: function [n]-> (2^n) + (neg 1)^n

JO: function [n]-> (J n) * (J n+1)

printFirst "Jacobsthal-Lucas numbers" 'JL [true] 30

printFirst "Jacobsthal oblong numbers" 'JO [true] 20

 

{{out}}

 

=={{header|AutoHotkey}}==

return SubStr(" " Format("{:.0f}", (2**n - (-1)**n ) / 3), -8)

}

ans.push(n)

return ans

loop 30

result .= Jacobsthal(A_Index-1) (mod(A_Index, 5) ? " ":"`n")

 

MsgBox, 262144, , % result

{{out}}

<pre>First 30 Jacobsthal numbers:

=={{header|C}}==

{{libheader|GMP}}

#include <gmp.h>

 

 

return 0;

 

{{out}}

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

{{libheader|GMP}}

 

#include <iomanip>

}

}

 

{{out}}

=={{header|Factor}}==

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

math.primes prettyprint sequences ;

 

 

"First 20 Jacobsthal primes:" print

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

If n < 2 Then Return False

If n Mod 2 = 0 Then Return false

Swap i0, i1

Loop Until c = 10

{{out}}

<pre>First 30 Jacobsthal numbers:

 

=={{header|Go}}==

 

import (

}

}

 

{{out}}

 

=={{header|Haskell}}==

jacobsthal = 0 : 1 : zipWith (\x y -> 2 * x + y) jacobsthal (tail jacobsthal)

 

putStrLn ""

putStrLn "First 10 Jacobsthal primes:"

{{out}}

<pre>

or, defined in terms of unfoldr:

 

import Data.List.Split (chunksOf)

import Data.Numbers.Primes (isPrime)

let ws = maximum . fmap length <$> transpose rows

pw = printf . flip intercalate ["%", "s"] . show

{{Out}}

<pre>30 terms of the Jacobsthal sequence:

Implementation:

 

 

Task examples:

 

0 1 1 3 5 11 21 43 85 171

341 683 1365 2731 5461 10923 21845 43691 87381 174763

232903 932295 3727815 14913991 59650503 238612935 954429895 3817763271 15270965703 61084037575

ja I.1 p:ja i.32 NB. first ten Jacobsthal primes

 

=={{header|jq}}==

 

'''Preliminaries'''

def chunks(n):

def c: .[0:n], (if length > n then .[n:]|c else empty end);

 

# To take advantage of gojq's arbitrary-precision integer arithmetic:

 

'''The Tasks'''

. as $n

| ( (2|power($n)) - (if ($n%2 == 0) then 1 else -1 end)) | divmod(3)[0];

;

 

{{out}}

<pre>

 

=={{header|Julia}}==

using Primes

 

printrows("Fifteen Jacabsthal prime numbers:", collect(take(15, Jprimes)), 40, 1, false)

 

<pre>

Thirty Jacobsthal numbers:

 

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

Jacobsthal[n_]:=(2^n-(-1)^n)/3

JacobsthalLucas[n_]:=2^n+(-1)^n

i++;

]][[2,1]]//Grid

{{out}}

<pre>{0, 1, 1, 3, 5, 11, 21, 43, 85, 171, 341, 683, 1365, 2731, 5461, 10923, 21845, 43691, 87381, 174763, 349525, 699051, 1398101, 2796203, 5592405, 11184811, 22369621, 44739243, 89478485, 178956971}

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use feature <say state>;

say "First 30 Jacobsthal-Lucas numbers:\n", table map { jacobsthal_lucas $_-1 } 1..30;

say "First 20 Jacobsthal oblong numbers:\n", table map { $j[$_-1] * $j[$_] } 1..20;

{{out}}

<pre>First 30 Jacobsthal numbers:

=={{header|Phix}}==

You can run this online [http://phix.x10.mx/p2js/jacobsthal.htm here].

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

<span style="color: #008080;">function</span> <span style="color: #000000;">jacobsthal</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;">n</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>

Likewise should you want the three basic functions to go further they'll have to look much more like the C submission above.

{{out}}

=={{header|Python}}==

{{trans|Phix}}

from math import floor, pow

 

for j in range(3, 33):

if isPrime(jacobsthal(j)):

 

{{out}}

Or, defining an infinite series in terms of a general unfoldr anamorphism:

 

 

from itertools import islice

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>30 terms of the Jacobsthal sequence:

 

=={{header|Raku}}==

my $jacobsthal-lucas = lazy 2, 1, * × 2 + * … *;

 

 

say "\nFirst 20 Jacobsthal primes:";

{{out}}

<pre>First 30 Jacobsthal numbers:

 

=={{header|Red}}==

 

jacobsthal: function [n] [to-integer (2 ** n - (-1 ** n) / 3)]

]

n: n + 1

{{out}}

<pre>

 

=={{header|Rust}}==

// rug = "0.3"

 

println!("{}", n);

}

 

{{out}}

 

=={{header|Sidef}}==

lucasU(1, -2, n)

}

 

say "\nFirst 20 Jacobsthal primes:";

 

{{out}}

{{trans|go}}

{{incomplete|Vlang|Probably Prime section isn't implemented yet (This is in development)}}

 

fn jacobsthal(n u32) big.Integer {

}

}*/

 

{{out}}

{{libheader|Wren-seq}}

{{libheader|Wren-fmt}}

import "./seq" for Lst

import "./fmt" for Fmt

}

System.print("\nFirst 20 Jacobsthal primes:")

 

{{out}}

 

=={{header|XPL0}}==

int N, I;

[if N <= 2 then return N = 2;

J2:= J1; J1:= J;

];

 

{{out}}