Padovan sequence: Difference between revisions

| || ||

|-

|-

| Recurrence relation. || P(n)=P(n-2)+P(n-3) || F(n)=F(n-1)+F(n-2)

| || 1.324717957244746025960908854… || 1.6180339887498948482...

|-

|-

| Ratio is real root of polynomial. || p: x**3-x-1 || g: x**2-x-1

| L-System Start/Axiom. || A || A

|-

|}

 

* [https://www.youtube.com/watch?v=PsGUEj4w9Cc The Plastic Ratio] - Numberphile video.

 

 

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

# recurance relation: P(n)=P(n-2)+P(n-3) #

OP PADOVANI = ( INT n )[]INT:

p

END; # PADOVANI #

# computing by truncation P(n)=floor(p^(n-1) / s + .5) #

# where s = 1.0453567932525329623 #

result

END; # PADOVANC #

OP PADOVANL = ( INT n )[]STRING:

BEGIN

)

END

{{out}}

<pre>

 

=={{header|AppleScript}}==

 

-- padovans :: [Int]

set my text item delimiters to dlm

s

{{Out}}

<pre>First 20 padovans:

 

=={{header|C}}==

#include <stdlib.h>

#include <math.h>

return 0;

 

{{out}}

 

The floor- and L-system-based functions match from P_0 to P_31.</pre>

 

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

#include <map>

#include <cmath>

"floor- and L-system-based", 32);

return 0;

 

{{out}}

 

The floor- and L-system-based functions match from P_0 to P_32.</pre>

=={{header|Factor}}==

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

memoize prettyprint qw sequences ;

 

 

32 <iota> [ pfloor ] map 32 plsys [ length ] map assert=

{{out}}

<pre>

The L-system, recurrence and floor based algorithms match to n=31.

</pre>

 

=={{header|Go}}==

{{trans|Wren}}

 

import (

}

fmt.Println("\nThe recurrence and L-system based functions", s, "the same results for 32 terms.")

 

{{out}}

 

=={{header|Haskell}}==

pRec = map (\(a,_,_) -> a) $ iterate (\(a,b,c) -> (b,c,a+b)) (1,1,1)

 

-- list of Padovan numbers generated from floor function

main = do

putStr "P_0 .. P_19: "

putStr "The floor- and recurrence-based functions "

putStr $ if checkN 64 pRec pFloor then "match" else "do not match"

putStr " from P_0 to P_63.\n\n"

putStr "The first 10 L-system strings are:\n"

putStr "\nThe floor- and L-system-based functions "

putStr $ if checkN 32 pFloor (map length lSystem)

then "match" else "do not match"

 

{{out}}

<pre>P_0 .. P_19: 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 49 65 86 114 151

The floor- and recurrence-based functions match from P_0 to P_63.

 

The first 10 L-system strings are:

 

 

 

--------------------- PADOVAN NUMBERS --------------------

 

padovans :: [Integer]

 

padovanFloor :: [Integer]

padovanFloor = unfoldr f 0

where

p = 1.324717957244746025960908854

s = 1.0453567932525329623

 

padovanLSystem :: [String]

padovanLSystem = unfoldr f "A"

where

rule 'A' = "B"

rule 'B' = "C"

rule 'C' = "AB"

 

-------------------------- TESTS -------------------------

 

prefixesMatch :: Eq a => [a] -> [a] -> Int -> Bool

{{Out}}

<pre>First 20 padovans:

 

True</pre>

 

=={{header|JavaScript}}==

"use strict";

 

// MAIN ---

return main();

{{Out}}

<pre>First 20 padovans:

true</pre>

 

 

 

 

 

 

 

 

 

 

 

end

 

end

<pre>

11 12 12 12

12 16 16 16

31 3329 3329 3329

32 4410 4410 4410

 

 

 

</pre>

 

 

 

 

{{out}}

<pre>

=={{Header|Python}}==

===Python: Idiomatic===

from collections import deque

from typing import Dict, Generator

print("\nThe L-system, recurrence and floor based algorithms match to n=31 .")

else:

 

{{out}}

The L-system, recurrence and floor based algorithms match to n=31 .</pre>

 

 

from itertools import chain, islice

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>First 20 padovans:

 

True</pre>

 

=={{header|Raku}}==

constant s = 1.0453567932525329623;

constant %rules = A => 'B', B => 'C', C => 'AB';

 

say "Recurrence == Floor to N=64" if (@pad-recur Z== @pad-floor).head(64).all;

{{out}}

<pre>

 

=={{header|REXX}}==

numeric digits 40 /*better precision for Plastic ratio. */

parse arg n nF Ln cL . /*obtain optional arguments from the CL*/

end /*j*/

say

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

<pre>

 

all 32 terms match for Padovan terms and lengths of L_sys terms.

</pre>

 

=={{header|Rust}}==

let mut p = vec![1, 1, 1];

let mut n = 0;

.eq(padovan_recur().take(32))

);

 

{{out}}

Length of first 32 strings produced from the L-system = Padovan sequence? true

</pre>

 

=={{header|Wren}}==

{{libheader|Wren-dynamic}}

L-System stuff is based on the Julia implementation.

 

var padovanRecur = Fn.new { |n|

areSame = (0...32).all { |i| recur[i] == lsyst[i] }

s = areSame ? "give" : "do not give"

 

{{out}}