Padovan n-step number sequences: Difference between revisions

{{trans|Nim}}

 

assert(k >= 2)

V result = I n == 2 {[1, 1, 1]} E rn(n - 1, n + 1)

 

L(n) 2..8

 

{{out}}

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

{{Trans|ALGOL W}}

# returns an array with the elements set to the elements of #

# the Padovan sequences from 2 to max s & elements 1 to max e #

print( ( newline ) )

OD

{{out}}

<pre>

 

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

% sets R(i,j) to the jth element of the ith padovan sequence %

% maxS is the number of sequences to generate and maxE is the %

end for_n

end

{{out}}

<pre>

 

=={{header|AppleScript}}==

use framework "Foundation"

use scripting additions

end tell

end if

{{Out}}

<pre>Padovan N-step Series:

=={{header|C}}==

{{trans|Wren}}

 

void padovanN(int n, size_t t, int *p) {

}

return 0;

 

{{out}}

 

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

// Padovan n-step number sequences. Nigel Galloway: July 28th., 2021

let rec pad=function 2->Seq.unfold(fun(n:int[])->Some(n.[0],Array.append n.[1..2] [|Array.sum n.[0..1]|]))[|1;1;1|]

|g->Seq.unfold(fun(n:int[])->Some(n.[0],Array.append n.[1..g] [|Array.sum n.[0..g-1]|]))(Array.ofSeq(pad(g-1)|>Seq.take(g+1)))

[2..8]|>List.iter(fun n->pad n|>Seq.take 15|>Seq.iter(printf "%d "); printfn "")

{{out}}

<pre>

=={{header|Factor}}==

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

math.ranges prettyprint sequences ;

 

 

"Padovan n-step sequences" print

{{out}}

<pre>

=={{header|Go}}==

{{trans|Wren}}

 

import "fmt"

fmt.Printf("%d: %3d\n", n, padovanN(n, t))

}

 

{{out}}

 

=={{header|Haskell}}==

import Data.List (transpose, uncons, unfoldr)

 

 

justifyRight :: Int -> a -> [a] -> [a]

{{Out}}

<pre>Padovan N-step series:

 

=={{header|JavaScript}}==

"use strict";

 

// MAIN ---

return main();

{{Out}}

<pre>Padovan N-step series:

=={{header|Julia}}==

{{trans|Python}}

"""

First nterms terms of the first 2..max_nstep -step Padovan sequences.

 

print_Padovan_seq(nstep_Padovan())

:::: {| style="text-align: left;" border="4" cellpadding="2" cellspacing="2"

|+ Padovan <math>n</math>-step sequences

 

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

Padovan[2,tmax_]:=Module[{start,a,m},

start={1,1,1};

Padovan[6,15]

Padovan[7,15]

{{out}}

<pre>{1,1,1,2,2,3,4,5,7,9,12,16,21,28,37}

 

=={{header|Nim}}==

 

proc rn(n, k: Positive): seq[int] =

 

for n in 2..8:

 

{{out}}

 

=={{header|Perl}}==

use warnings;

use feature <state say>;

print ' ' . $pad_n->next() for 1..25;

print "\n"

{{out}}

<pre>N = 2 | 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 49 65 86 114 151 200 265 351 465 616

=={{header|Phix}}==

{{trans|Go}}

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

<span style="color: #008080;">function</span> <span style="color: #000000;">padovann</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;">t</span><span style="color: #0000FF;">)</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: #000000;">fmt</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">&</span><span style="color: #000000;">padovann</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">t</span><span style="color: #0000FF;">))</span>

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

{{out}}

<pre>

===Python: Procedural===

Generates a wikitable formatted output

"""

First t terms of the first 2..max_n-step Padovan sequences.

if __name__ == '__main__':

p = pad_like()

 

{{out}}

Patterns of functional composition are constrained more by mathematical necessity than by arbitrary convention, but this still leaves room for alternative idioms of functional coding in Python. It is to be hoped that others will contribute divergent examples, enriching the opportunities for contrastive insight which Rosetta code aims to provide.

 

 

from itertools import chain, islice, repeat

if __name__ == '__main__':

main()

{{Out}}

<pre>Padovan n-step series:

 

=={{header|Raku}}==

 

for 2..8 -> \N {

my @n-step = 1, 1, 1, { state $n = 2; @n-step[ ($n - N .. $n++ - 1).grep: * >= 0 ].sum } … *;

put "N = {N} |" ~ @n-step[^25]».fmt: "%5d";

{{out}}

<pre>Padovan N-step sequences; first 25 terms:

=={{header|REXX}}==

Some additional code was added for this REXX version to minimize the width for any particular column.

parse arg n m . /*obtain optional arguments from the CL*/

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

/*──────────────────────────────────────────────────────────────────────────────────────*/

pd: procedure expose @. #; parse arg x; if @.x\==0 then return @.x /*@.x defined?*/

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

<pre>

 

=={{header|Rust}}==

fn padovan(n: u64, x: u64) -> u64 {

if n < 2 {

}

 

{{out}}

<pre>

=={{header|Sidef}}==

{{trans|Perl}}

Enumerator({|callback|

var n = 2

for n in (2..8) {

say "n = #{n} | #{padovan(n).first(25).join(' ')}"

{{out}}

<pre>

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var padovanN // recursive

var t = 15

System.print("First %(t) terms of the Padovan n-step number sequences:")

 

{{out}}