Leonardo numbers: Difference between revisions

{{trans|C++}}

L 1..cnt

print(l0, end' ‘ ’)

leo_numbers(25)

print(‘Fibonacci Numbers: ’, end' ‘’)

{{out}}

=={{header|Action!}}==

CARD curr,prev,tmp

PrintF("L(%B)=%U",n,l)

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Leonardo_numbers.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

procedure Leonardo is

end loop;

New_Line;

{{out}}

<pre>

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

# leonardo number parameters #

MODE LEONARDO = STRUCT( INT l0, l1, add number );

show( 25, leonardo numbers WITHLZERO 0 WITHADDNUMBER 0 );

print( ( newline ) )

{{out}}

<pre>

Drawing N items from a non-finite generator:

-- leo :: Int -> Int -> Int -> Generator [Int]

set my text item delimiters to dlm

str

{{Out}}

<pre>First 25 Leonardo numbers:

===Idiomatic===

Allowing optional 'L0', 'L1', and/or 'add' specs with any version of AppleScript.

on leonardos(spec, quantity)

-- Assign the spec values to variables, using defaults for any not given.

" & leonardos({L0:0, L1:1, add:0}, 25)

set AppleScript's text item delimiters to astid

{{output}}

1, 1, 3, 5, 9, 15, 25, 41, 67, 109, 177, 287, 465, 753, 1219, 1973, 3193, 5167, 8361, 13529, 21891, 35421, 57313, 92735, 150049

1st 25 Fibonaccis:

=={{header|Arturo}}==

(n=0)? -> l0 [

(n=1)? -> l1

print ""

print "The first 25 Leonardo numbers with L0=0, L1=1, LADD=0"

{{out}}

=={{header|AutoHotkey}}==

if n=0

return L0

return L1

return Leonardo(n-1, L0, L1, step) + Leonardo(n-2, L0, L1, step) + step

loop, 25

output .= Leonardo(A_Index-1) " "

output .= Leonardo(A_Index-1, 0, 1, 0) " "

MsgBox % output

{{out}}

<pre>1st 25 Leonardo numbers, starting at L(0).

=={{header|AWK}}==

# syntax: GAWK -f LEONARDO_NUMBERS.AWK

BEGIN {

printf("\n")

}

{{out}}

<pre>

=={{header|Bash}}==

#!/bin/bash

echo "${leonardo_numbers[*]}"

}

{{out}}

<pre>

=={{header|BASIC}}==

==={{header|BASIC256}}===

subroutine leonardo(L0, L1, suma, texto)

print "Numeros de " + texto + " (" + L0 + "," + L1 + "," + suma + "):"

call leonardo(0,1,0,"Fibonacci")

end

{{out}}

<pre>

==={{header|IS-BASIC}}===

110 INPUT PROMPT "Enter values of L0, L1, and ADD, separated by comas: ":L0,L1,ADD

120 PRINT L0;L1;

160 PRINT L1;

170 NEXT

==={{header|Sinclair ZX81 BASIC}}===

Runs on the 1k RAM model with room to spare; hence the long(ish) variable names. The parameters are read from the keyboard.

20 INPUT L1

30 INPUT ADD

80 LET L0=TEMP

90 PRINT " ";L1;

{{in}}

<pre>1

=={{header|BBC BASIC}}==

It's a shame when fonts don't make much of a distinction between <tt>l</tt> lower-case L and <tt>1</tt> the number One.

:

PRINT "Enter values of L0, L1, and ADD, separated by commas:"

NEXT

PRINT

{{out}}

<pre>Enter values of L0, L1, and ADD, separated by commas:

=={{header|Burlesque}}==

1 1 3 5 9 15 25 41 67 109 177 287 465 753 1219 1973 3193 5167 8361 13529 21891 35421 57313 92735 150049

blsq ) 0 1 0{.+\/.+}\/+]23!CCLm]wdsh

=={{header|C}}==

This implementation fulfills the task requirements which state that the first 2 terms and the step increment should be specified. Many other implementations on this page only print out the first 25 numbers.

#include<stdio.h>

return 0;

}

Output :

Normal Leonardo Series :

=={{header|C sharp}}==

{{works with|C sharp|7}}

using System.Linq;

}

}

{{out}}

<pre>

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

#include <iostream>

return 0;

}

{{out}}<pre>

Leonardo Numbers: 1 1 3 5 9 15 25 41 67 109 177 287 465 753 1219 1973 3193 5167 8361 13529 21891 35421 57313 92735 150049

=={{header|Common Lisp}}==

;;;

;;; leo - calculates the first n number from a leo sequence.

(cond ((= n 1) (list a))

(T (iterate (- n 2) (list b a))))))

{{out}}

=={{header|Crystal}}==

{{trans|Python}}

terms = [l_zero, l_one]

while terms.size < amount

puts "First 25 Leonardo numbers: \n#{ leonardo(1,1,1,25) }"

puts "Leonardo numbers with fibonacci parameters:\n#{ leonardo(0,1,0,25) }"

{{out}}

<pre>

=={{header|D}}==

{{trans|C++}}

import std.stdio;

writeln();

}

{{out}}<pre>

Leonardo Numbers: 1 1 3 5 9 15 25 41 67 109 177 287 465 753 1219 1973 3193 5167 8361 13529 21891 35421 57313 92735 150049

=={{header|F#|F sharp}}==

{{trans|Haskell}}

let leo l0 l1 d =

printfn "First 25 of the (0, 1, 0) Leonardo numbers (= Fibonacci number):\n%A" fibNums

{{out}}

<pre>First 25 of the (1, 1, 1) Leonardo numbers:

=={{header|Factor}}==

IN: rosetta-code.leonardo-numbers

"First 25 Leonardo numbers with L(0)=0, L(1)=1, add=0:" print

{{out}}

<pre>

=={{header|Fermat}}==

Array leo[1,size]; {set up as a row rather than column vector; looks nicer to print}

leo[1,1]:=l0; leo[1,2]:=l1; {fermat arrays are 1-indexed}

Leonardo(25, 0, 1, 0);

{{out}}

<pre>[[ 1, 1, 3, 5, 9, 15, 25, 41, 67, 109, 177, 287, 465, 753, 1219, 1973, 3193, 5167, 8361, 13529, 21891, 35421, 57313, 92735, 150049 ]]

Many versions of Fortran have enabled parameters to be optionally supplied and F90 has standardised a protocol, also introducing a declaration syntax that can specify multiple attributes in one statement which in this case would be <code>INTEGER, OPTIONAL:: AF</code> rather than two statements concerning AF. However, in a test run with <code>CALL LEONARDO(25,1,1)</code> the Compaq F90/95 compiler rejected this attempt because there was another invocation with four parameters, not three, in the same program unit. By adding the rigmarole for declaring a MODULE containing the subroutine LEONARDO, its worries would be assuaged. Many compilers (and linkers, for separately-compiled routines) would check neither the number nor the type of parameters so no such complaint would be made - but when run, the code might produce wrong results or crash.

INTEGER LAST !Limit to show.

INTEGER L0,L1 !Starting values.

CALL LEONARDO(25,1,1,1) !The first 25 Leonardo numbers.

CALL LEONARDO(25,0,1,0) !Deviates to give the Fibonacci sequence.

Output:

<pre>

=={{header|FreeBASIC}}==

Sub leonardo(L0 As Integer, L1 As Integer, suma As Integer, texto As String)

Dim As Integer i, tmp

leonardo(0,1,0,"Fibonacci")

End

{{out}}

<pre>

=={{header|Go}}==

import "fmt"

fmt.Println("\nThe first 25 Leonardo numbers with L[0] = 0, L[1] = 1 and add number = 0 are:")

fmt.Println(leonardo(25, 0, 1, 0))

{{out}}

=={{header|Haskell}}==

import Data.List.Split (chunksOf)

]

where

{{Out}}

<pre>First 25 default (1, 1, 1) Leonardo numbers:

Alternately, defining the list self-referentially instead of using unfoldr:

leo l0 l1 d = s where

=={{header|J}}==

leo =: (] , {.@[ + _2&{@] + {:@])^:(_2&+@{:@[)

{{Out}}

<pre>

=={{header|Java}}==

{{trans|Kotlin}}

import java.util.List;

System.out.println(leonardo(25, 0, 1, 0));

}

{{out}}

<pre>The first 25 Leonardo numbers with L[0] = 1, L[1] = 1 and add number = 1 are:

=={{header|JavaScript}}==

===ES6===

new Array(c).fill(add).reduce(

(p, c, i) => i > 1 ? (

console.log(leoNum(25));

<pre>

Or, taking N terms from a non-finite Javascript generator:

{{Trans|Python}}

'use strict';

// MAIN ---

return main();

{{Out}}

<pre>First 25 Leonardo numbers:

=={{header|jq}}==

===Naive Implementation===

def leo:

if . == 0 then zero

else ((.-1) |leo) + ((.-2) | leo) + incr

end;

===Implementation with Caching===

An array is used for caching, with `.[n]` storing the value L(n).

def leo(n):

if .[n] then .

| .[n] = .[n-1] + .[n-2] + incr

end;

(To compute the sequence of Leonardo numbers L(1) ... L(n) without redundant computation, the last element of the pipeline in the last line of the function above should be dropped.)

'''Examples'''

{{out}}

<pre>[1,1,3,5,9,15,25,41,67,109,177,287,465,753,1219,1973,3193,5167,8361,13529,21891,35421,57313,92735,150049]</pre>

{{out}}

<pre>[0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368]</pre>

{{works with|Julia|0.6}}

l = max(maximum(n) .+ 1, length(firsts))

r = Vector{Int}(l)

# Task 4

{{out}}

=={{header|Kotlin}}==

fun leonardo(n: Int, l0: Int = 1, l1: Int = 1, add: Int = 1): IntArray {

println("\nThe first 25 Leonardo numbers with L[0] = 0, L[1] = 1 and add number = 0 are:")

println(leonardo(25, 0, 1, 0).joinToString(" "))

{{out}}

=={{header|Lua}}==

local L0, L1, add = L0 or 1, L1 or 1, add or 1

local lNums, nextNum = {L0, L1}

show("Leonardo numbers", leoNums(25))

{{out}}

<pre>Leonardo numbers:

=={{header|Maple}}==

if n = 0 then

return L_0;

Leonardo := n -> (L(1, 1, 1),[seq(0..n - 1)])

<pre>[1, 1, 3, 5, 9, 15, 25, 41, 67, 109, 177, 287, 465, 753, 1219, 1973, 3193, 5167, 8361, 13529, 21891, 35421, 57313, 92735, 150049]

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368]</pre>

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

L[1,L0_:1,L1_:1,___]:=L1

L[n_,L0_:1,L1_:1,add_:1]:=L[n-1,L0,L1,add]+L[n-2,L0,L1,add]+add

L/@(Range[25]-1)

<pre>{1, 1, 3, 5, 9, 15, 25, 41, 67, 109, 177, 287, 465, 753, 1219, 1973, 3193, 5167, 8361, 13529, 21891, 35421, 57313, 92735, 150049}

=={{header|min}}==

{{works with|min|0.19.3}}

(('print dip " " print! next) 25 times newline) :leo

1 1 1 leo

"First 25 Leonardo numbers with add=0, L(0)=0, L(1)=1:" puts!

{{out}}

<pre>

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

ReadChar

=={{header|Nim}}==

proc leonardoNumbers(count: int, L0: int = 1,

leonardoNumbers(25)

echo "Fibonacci Numbers: "

{{out}}

<pre>

=={{header|Perl}}==

use feature 'signatures';

print "Leonardo[1,1,1]: @L\n";

my @F = map { leonardo($_,0,1,0) } 0..24;

{{out}}

<pre>Leonardo[1,1,1]: 1 1 3 5 9 15 25 41 67 109 177 287 465 753 1219 1973 3193 5167 8361 13529 21891 35421 57313 92735 150049

=={{header|Phix}}==

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

<span style="color: #008080;">function</span> <span style="color: #000000;">leonardo</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;">l1</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">l2</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">step</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?{</span><span style="color: #008000;">"Leonardo"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">leonardo</span><span style="color: #0000FF;">(</span><span style="color: #000000;">25</span><span style="color: #0000FF;">)}</span>

<span style="color: #0000FF;">?{</span><span style="color: #008000;">"Fibonacci"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">leonardo</span><span style="color: #0000FF;">(</span><span style="color: #000000;">25</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)}</span>

{{out}}

<pre>

=={{header|Picat}}==

println([leonardo(I) : I in 0..24]),

println([leonardo(0,1,0,I) : I in 0..24]).

leonardo(I1,_I2,_Add,0) = I1.

leonardo(_I1,I2,_Add,1) = I2.

{{out}}

=={{header|PicoLisp}}==

(default A 1 B 1 C 1)

(make

(println 'Leonardo (leo))

{{out}}

<pre>Leonardo (1 1 3 5 9 15 25 41 67 109 177 287 465 753 1219 1973 3193 5167 8361 13529 21891 35421 57313 92735 150049)

=={{header|Plain English}}==

Start up.

Write "First 25 Leonardo numbers:" on the console.

Put the first number plus the second number plus the add number into the second number.

Write the second number then " " on the console without advancing.

{{out}}

<pre>

=={{header|PureBasic}}==

EnableExplicit

r$ = Input()

EndIf

{{out}}

<pre>

=={{header|Python}}==

===Finite iteration===

terms = [L_Zero,L_One]

while len(terms) < Amount:

out += str(term) + " "

print out

{{out}}

<pre>

Or, for a non-finite stream of Leonardos, we can use a Python generator:

{{Works with|Python|3}}

from functools import (reduce)

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>First 25 Leonardo numbers:

=={{header|Quackery}}==

[ 0 1 0 ] is fibo ( --> n n n )

cr cr

say "Lucas numbers:" cr

{{out}}

=={{header|R}}==

leonardo_numbers <- function(add = 1, l0 = 1, l1 = 1, how_many = 25) {

result <- c(l0, l1)

cat("First 25 Leonardo numbers from 0, 1 with add number = 0\n")

cat(leonardo_numbers(0, 0, 1), "\n")

{{out}}

<pre>

=={{header|Racket}}==

(define (Leonardo n #:L0 (L0 1) #:L1 (L1 1) #:1+ (1+ 1))

(cond [(= n 0) L0]

(check-equal? (Leonardo 1) 1)

(check-equal? (Leonardo 2) 3)

{{out}}

(formerly Perl 6)

# Part 1

# Part 2

say "\nThe first 25 numbers using 𝑳0 of 0, 𝑳1 of 1, and adder of 0:";

{{out}}

<pre>The first 25 Leonardo numbers:

=={{header|REXX}}==

numeric digits 500 /*just in case the user gets ka-razy. */

@.=1 /*define the default for the @. array.*/

$=$ z /*append the just computed # to $ list.*/

end /*j*/ /* [↓] elide the leading blank in $. */

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

<pre>

=={{header|Ring}}==

# Project : Leanardo numbers

next

see nl

Output:

<pre>

=={{header|Ruby}}==

Enumerators are nice for this.

return to_enum(__method__,l0,l1,add) unless block_given?

loop do

p leonardo.take(25)

p leonardo(0,1,0).take(25)

{{out}}

<pre>[1, 1, 3, 5, 9, 15, 25, 41, 67, 109, 177, 287, 465, 753, 1219, 1973, 3193, 5167, 8361, 13529, 21891, 35421, 57313, 92735, 150049]

=={{header|Run BASIC}}==

#mem execute("CREATE TABLE lno (name,L0,L1,ad)")

#mem execute("INSERT INTO lno VALUES('Leonardo',1,1,1),('Fibonacci',0,1,0);")

next i

next j

<pre>Leonardo add=1

1 1 3 5 9 15 25 41 67 109 177 287 465 753 1219 1973 3193 5167 8361 13529 21891 35421 57313 92735 150049

=={{header|Rust}}==

std::iter::from_fn(move || {

let n = n0;

}

println!();

{{out}}

=={{header|Scala}}==

case 0 => n1

case 1 => n2

(0 until 25) foreach { n => print( leo(n, n1=0, n2=1, addnum=0) + " " ) }

}

{{out}}

<pre>The first 25 Leonardo Numbers:

=={{header|Seed7}}==

const proc: leonardo (in var integer: l0, in var integer: l1, in integer: add, in integer: count) is func

write("Fibonacci Numbers:");

leonardo(0, 1, 0, 25);

{{out}}

=={{header|Sidef}}==

{ (𝑳0, 𝑳1) = (𝑳1, 𝑳0 + 𝑳1 + 𝑳add) } * n

return 𝑳0

say "\nThe first 25 numbers using 𝑳0 of 0, 𝑳1 of 1, and adder of 0:"

{{out}}

<pre>

=={{header|Swift}}==

private let add : Int

private var n0: Int

print("First 25 Fibonacci numbers:")

{{out}}

=={{header|VBA}}==

Option Explicit

Leo_Numbers = Ltemp

End Function

{{out}}

<pre>First 25 Leonardo numbers :

=={{header|Visual Basic .NET}}==

{{trans|C#}}

Iterator Function Leonardo(Optional L0 = 1, Optional L1 = 1, Optional add = 1) As IEnumerable(Of Integer)

End Sub

{{out}}

<pre>1 1 3 5 9 15 25 41 67 109 177 287 465 753 1219 1973 3193 5167 8361 13529 21891 35421 57313 92735 150049

=={{header|Vlang}}==

{{trans|go}}

mut leo := []int{len: n}

leo[0] = l0

println("\nThe first 25 Leonardo numbers with L[0] = 0, L[1] = 1 and add number = 0 are:")

println(leonardo(25, 0, 1, 0))

{{out}}

=={{header|Wren}}==

var leo = List.filled(limit, 0)

leo[0] = first[0]

System.print("\n\nThe first 25 Leonardo numbers with L(0) = 0, L(1) = 1 and Add = 0 are:")

for (l in leonardo.call([0, 1], 0, 25)) System.write("%(l) ")

{{out}}

=={{header|Yabasic}}==

sub leonardo(L0, L1, suma, texto$)

leonardo(1,1,1,"Leonardo")

leonardo(0,1,0,"Fibonacci")

=={{header|XPL0}}==

[Text(0, "Enter L(0), L(1), Add: ");

L0:= IntIn(0);

L1:= L;

];

{{out}}

=={{header|zkl}}==

if(n==0) return(n1);

if(n==1) return(n2);

self.fcn(n-1,n1,n2,addnum) + self.fcn(n-2,n1,n2,addnum) + addnum

foreach n in (25){ print(leonardoNumber(n)," ") }

println("\n");

println("The first 25 Fibonacci Numbers:");

foreach n in (25){ print(leonardoNumber(n, 0,1,0)," ") }

{{out}}

<pre>