Padovan n-step number sequences: Difference between revisions

# Use this to print and show here at least the first <code>t=15</code> values of the first <code>2..8</code> <math>n</math>-step sequences.<br> (The [https://oeis.org OEIS] column in the table above should be omitted).

<br><br>

 

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

7 -> 1 1 1 2 3 5 8 13 21 33 53 85 136 218 349

8 -> 1 1 1 2 3 5 8 13 21 34 54 87 140 225 362</pre>

 

=={{header|C}}==

{{trans|Wren}}

 

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

}

return 0;

 

{{out}}

7: 1 1 1 2 3 5 8 13 21 33 53 85 136 218 349

8: 1 1 1 2 3 5 8 13 21 34 54 87 140 225 362

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

 

------------------ PADOVAN N-STEP SERIES -----------------

padovans n

| 0 > n = []

where

xs

| 3 > n = repeat 1

| otherwise = padovans $ pred n

 

--------------------------- TEST -------------------------

main =

putStrLn $

 

------------------------ FORMATTING ----------------------

 

unlines $

fmap

where

 

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

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

 

'''Non-finite series of N-step Padovan numbers,

defined by a recurrence relation.

'''

take(1 + n)(

)

# ------------------------- TEST -------------------------

# main :: IO ()

def main():

where n is drawn from [2..8]

'''

print(

)

# ----------------------- GENERIC ------------------------

# unfoldr :: (b -> Maybe (a, b)) -> b -> [a]

def unfoldr(f):

valueResidue = f(valueResidue[1])

return go

# ---------------------- FORMATTING ----------------------

'''

# MAIN ---

if __name__ == '__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>

8 │ 1 1 1 2 3 5 8 13 21 34 54 87 140 225 362

───┴──────────────────────────────────────────

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

7: 1 1 1 2 3 5 8 13 21 33 53 85 136 218 349

8: 1 1 1 2 3 5 8 13 21 34 54 87 140 225 362

</pre>