Padovan sequence: Difference between revisions

{{trans|Nim}}

 

V ss = 1.0453567932525329623

V Rules = [‘A’ = ‘B’, ‘B’ = ‘C’, ‘C’ = ‘AB’]

V list3 = padovan3(32).map(x -> x.len)

print(list3.join(‘ ’))

 

{{out}}

 

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

 

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

#include <map>

#include <cmath>

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

return 0;

 

{{out}}

 

=={{header|Clojure}}==

 

(def pad-floor

"The L-system, recurrence and floor based algorithms "

(if (comp-all 32) "match" "not match")

 

{{out}}

Thanks Rudy Velthuis for the [https://github.com/rvelthuis/DelphiBigNumbers Velthuis.BigDecimals] library.<br>

Boost.Generics.Collection is part of [https://github.com/MaiconSoft/DelphiBoostLib DelphiBoostLib].

program Padovan_sequence;

 

end, 'floor- and L-system-based', 32);

readln;

 

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

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

 

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

{{Out}}

<pre>First 20 padovans:

 

Implementation:

padovanSeq=: (],+/@(_2 _3{]))^:([-3:)&1 1 1

 

padovanL=: rplc&('A';'B'; 'B';'C'; 'C';'AB')@]^:[&'A'

seqLen=. #@(-.&' ')"1

 

Typically, inductive sequences based on a function F with an initial value G can be expressed using an expression of the form F@]^:[@G or something similar. Here, [ represents the argument to the derived recurrence function. For padovanSeq, we are generating a sequence, so we want to retain the previous values. So instead of just using f=: +/@(_2 3{]) which adds up the second and third numbers from the end of the sequence, we also retain the previous values using F=: ],f

Task examples:

 

padovanSeq 20

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

(padovanSeq 32) -: seqLen padovanL i.32

1

 

=={{header|JavaScript}}==

"use strict";

 

// MAIN ---

return main();

{{Out}}

<pre>First 20 padovans:

streams of the Padovan strings and numbers respectively.

 

def padovanRecur($n):

[range(0;$n) | 1] as $p

;

 

{{out}}

<pre>

 

=={{header|Julia}}==

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

 

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

 

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

p=N[Surd[((9+Sqrt[69])/18),3]+Surd[((9-Sqrt[69])/18),3],200];

s=1.0453567932525329623;

Padovan1[64]===Padovan2[64]

SubstitutionSystem[{"A"->"B","B"->"C","C"->"AB"},"A",10]//Column

{{out}}

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

 

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

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

<span style="color: #004080;">sequence</span> <span style="color: #000000;">padovan</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</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: #008000;">"The first 10 L-system strings: %v\n\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">l10</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: #008000;">"recursive, algorithmic, and l-system agree to n=64\n"</span><span style="color: #0000FF;">)</span>

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

 

===Python: Expressed in terms of a generic anamorphism (unfoldr)===

 

from itertools import chain, islice

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>First 20 padovans:

<code>v**</code> is defined at [[Exponentiation operator#Quackery]].

 

[ dup 0 = iff

[ say "The first 32 recurrence terms and L System lengths are the same." ]

else [ say "Oh no! It's all gone pear-shaped!" ]

 

{{out}}

 

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

 

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

</pre>

=={{header|Rust}}==

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

let mut n = 0;

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

);

 

{{out}}

 

=={{header|Swift}}==

 

class PadovanRecurrence: Sequence, IteratorProtocol {

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

.elementsEqual(PadovanRecurrence().prefix(32))

 

{{out}}

{{libheader|Wren-dynamic}}

L-System stuff is based on the Julia implementation.

import "/dynamic" for Struct

 

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

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

 

{{out}}