Padovan sequence: Difference between revisions

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

|-

|}

 

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

 

 

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

# returns the first n elements of the Padovan sequence by the #

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

)

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)

 

putStr $ if checkN 32 pFloor (map length lSystem)

then "match" else "do not match"

 

{{out}}

 

and a variant expressed in terms of '''unfoldr''', which allows for a coherent treatment of these three cases – isolating the respects in which they differ – and also lends itself to a simple translation to the N-Step Padovan case, covered in another task.

 

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

where

f (a, b, c) = Just (a, (b, c, a + b))

 

padovanFloor :: [Integer]

where

f = Just . (((,) . g) <*> succ)

p = 1.324717957244746025960908854

s = 1.0453567932525329623

 

padovanLSystem :: [String]

where

f = Just . ((,) <*> concatMap rule)

rule 'A' = "B"

rule 'B' = "C"

 

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>

 

=={{header|Julia}}==

rPadovan(n) = (n < 4) ? one(n) : rPadovan(n - 3) + rPadovan(n - 2)

 

function fPadovan(n)::Int

p, s = big"1.324717957244746025960908854", big"1.0453567932525329623"

end

 

rules = Dict("A" => "B", "B" => "C", "C" => "AB")

seq, lens = ["A"], [1]

 

const lr, lf = [rPadovan(i) for i in 1:64], [fPadovan(i) for i in 1:64]

println("N Recursive Floor LSystem String\n=============================================")

foreach(i -> println(rpad(i, 4), rpad(lr[i], 12), rpad(lf[i], 12),

rpad(i < 33 ? lL[i] : "", 12), (i < 11 ? sL[i] : "")), 1:64)

<pre>

N Recursive Floor LSystem String

64 35676949 35676949

</pre>

 

=={{header|Nim}}==

 

const

echo "These lengths are",

if list3 == list1[0..31]: " " else: " not ",

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature <state say>;

 

$pr[$_] == $pf[$_] and $pr[$_] == length $L[$_] or die "Uh oh, n=$_: $pr[$_] vs $pf[$_] vs " . length $L[$_] for 0 .. $n-1;

{{out}}

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

 

=={{header|Phix}}==

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

ar = [1, 1, 1]

loop do

bool = l_system.take(n).map(&:size) == padovan.take(n)

puts "Sizes of first #{n} l_system strings equal to recurrence padovan? #{bool}."

{{out}}

<pre>Recurrence Padovan: [1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37, 49, 65, 86, 114, 151]

Sizes of first 32 l_system strings equal to recurrence padovan? true.

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

 

class PadovanRecurrence: Sequence, IteratorProtocol {

b = PadovanLSystem().prefix(32).map{$0.count}

.elementsEqual(PadovanRecurrence().prefix(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}}