Loops/Downward for: Difference between revisions

 

=={{header|11l}}==

 

=={{header|360 Assembly}}==

Use of BXLE and BCT opcodes.

LOOPDOWN CSECT

USING LOOPDOWN,R12

BUFFER DC CL80' '

YREGS

 

=={{header|6502 Assembly}}==

Code is called as a subroutine (i.e. JSR Start).

Printing routines are only partially coded here, specific OS/hardware routines for printing are left unimplemented.

;value contained in the Accumulator

Send = $9000 ;routine not implemented here

ORA #$30

JSR Send ;routine not implemented here

 

=={{header|68000 Assembly}}==

Code is called as a subroutine, i.e. "JSR ForLoop." OS/Hardware specific printing subroutines are unimplemented here.

MOVE.W #10,D0

loop:

JSR Print_D0_As_Ascii ;some routine that converts the digits of D0 into ascii characters and prints them to screen.

DBRA D0,loop ;repeat until D0.W = $FFFF

 

=={{header|8086 Assembly}}==

It is typically much easier for assembly languages to loop downwards than forwards, as they can do so without using a redundant equality check. The 8086's <code>LOOP</code> instruction will loop a section of code, using the <code>CX</code> register as the loop counter.

 

.stack 1024 ;reserve 1 KB for the stack pointer.

ret

 

 

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program loopdownward64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

=={{header|Ada}}==

Put_Line(Integer'Image(I));

 

=={{header|Agena}}==

Tested with Agena 2.9.5 Win32

print( i )

 

=={{header|ALGOL 60}}==

'''begin'''

'''integer''' i;

'''for''' i:=10 '''step''' -1 '''until''' 0 '''do'''

'''end'''

{{works with|ALGOL 60|OS/360}}

'INTEGER' I;

'FOR' I := 10 'STEP' -1 'UNTIL' 0 'DO'

OUTINTEGER(1,I)

 

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

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}

print((i,new line))

As a common extension the DOWNTO is sometimes included to optimise

the loop termination logic. The DOWNTO is available in Marcel's

[[ALGOL 68G]] and [[Cambridge ALGOL 68C]].

print((i,new line))

 

=={{header|ALGOL W}}==

for i := 10 step -1 until 0 do

begin

write( i )

end

 

=={{header|AmigaE}}==

DEF i

FOR i := 10 TO 0 STEP -1

WriteF('\d\n', i)

ENDFOR

 

=={{header|AppleScript}}==

log i

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

 

 

 

=={{header|Arturo}}==

print i

 

{{out}}

1

0</pre>

 

=={{header|AutoHotkey}}==

While (x >= 0)

{

}

MsgBox % output

 

=={{header|Avail}}==

Note that <code>10 to 0 by -1</code> section isn't a fixed part of the loop syntax, but a call to the <code>_to_by_</code> method, which returns a tuple of integers in a range separated by a particular step size, in this case returning <code><10, 9, 8, 7, 6, 5, 4, 3, 2, 1></code>.

 

=={{header|AWK}}==

for(i=10; i>=0; i--) {

print i

}

 

=={{header|Axe}}==

Axe does not support for loops with step sizes other than 1.

Disp 10-I▶Dec,i

 

=={{header|BASIC}}==

==={{header|Applesoft BASIC}}===

 

==={{header|BaCon}}===

 

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

{{works with|QBasic}}

print i; " ";

next i

print

 

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

PRINT i%

 

==={{header|Commodore BASIC}}===

20 PRINT I

 

==={{header|FreeBASIC}}===

 

For i As Integer = 10 To 0 Step -1

Next

Print

{{out}}

 

==={{header|FutureBasic}}===

 

 

for i = 10 to 0 step -1

print i

next

Output:

9

8

2

1

 

==={{header|Gambas}}===

'''[https://gambas-playground.proko.eu/?gist=b236db5bdb1087fa90e934a5a8210e1f Click this link to run this code]'''

Dim siCount As Short

 

Next

 

Output:

 

==={{header|GW-BASIC}}===

{{works with|PC-BASIC|any}}

20 PRINT I%

 

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

110 PRINT I

 

==={{header|Liberty BASIC}}===

print i

next i

 

==={{header|Microsoft Small Basic}}===

For i = 10 To 0 Step -1

TextWindow.WriteLine(i)

 

==={{header|NS-HUBASIC}}===

20 PRINT I

 

==={{header|PureBasic}}===

Debug i

 

==={{header|QB64}}===

''CBTJD'': 2020/03/14

PRINT n

 

print i

 

==={{header|TI-83 BASIC}}===

:Disp I

 

==={{header|TI-89 BASIC}}===

For i, 10, 0, –1

Disp i

 

==={{header|True BASIC}}===

{{works with|QBasic}}

PRINT i; " ";

NEXT i

PRINT

 

 

==={{header|XBasic}}===

{{works with|Windows XBasic}}

 

DECLARE FUNCTION Entry()

NEXT i%

END FUNCTION

 

==={{header|ZX Spectrum Basic}}===

20 PRINT l

 

=={{header|Batch File}}==

 

=={{header|bc}}==

 

=={{header|Befunge}}==

 

=={{header|BQN}}==

Each (<code>¨</code>) is an operator in BQN that helps with emulating loops like for and foreach.

 

 

=={{header|Bracmat}}==

 

=={{header|Brainf***}}==

<+.-. //print the digits 1 and 0

>++++++++++. //cell 1 now contains the carriage return; print it!

<<+++++++++>> //cell 0 now contains 57 the ASCII code for "9"

[<<.->.>-] //print and decrement the display digit; print a newline; decrement the loop variable

 

=={{header|Brat}}==

 

=={{header|C}}==

for(i = 10; i >= 0; --i)

 

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

 

{

Console.WriteLine(i);

 

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

 

=={{header|Ceylon}}==

print(i);

 

=={{header|Chapel}}==

 

 

In case you wonder why it is not written as <tt>10..1 by -1</tt>: <tt>by</tt> is an operator that works on ranges, and it should work the same when the range was defined earlier, like in

 

 

=={{header|Clipper}}==

? i

 

=={{header|Clojure}}==

 

=={{header|COBOL}}==

free-form

program-id. countdown.

environment division.

display counter-disp

end-perform

{{out}}

<pre>10

This could be written either in the array comprehension style,

or in "regular" for loop style.

console.log i for i in [10..0]

 

 

# More compact version of the above

<pre>10

9

=={{header|ColdFusion}}==

With tags:

#i#

With script:

for( i = 10; i <= 0; i-- )

{

writeOutput( i );

}

 

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

 

=== Using DO ===

(do ((n 10 (decf n))) ; Initialize to 0 and downward in every loop

((< n 0)) ; Break condition when negative

(print n)) ; On every loop print value

 

=== Using Tagbody and Go ===

(let ((count 10)) ; Create local variable count = 10

(tagbody

(if (not (< count 0)) ; Ends loop when negative

(go dec)))) ; Loops back to tag dec

 

=== Using Recursion ===

(defun down-to-0 (count)

(print count)

(down-to-0 (1- count))))

(down-to-0 10)

 

{{out}}

</pre>

 

=={{header|Crystal}}==

puts i

}

 

=={{header|D}}==

 

void main() {

foreach_reverse (i ; 0 .. 10 + 1)

writeln(i);

{{out}}

<pre>10

0</pre>

 

 

does not use GNU extensions

 

uses the macro f - [p] to print, this can be replaced by any complex expressions.

 

 

[macro s(swap) - (a b : b a)]s.

 

0 10 ldx [p] sf !<m

 

Using it

10

9

...

 

=={{header|Delphi}}==

 

=={{header|Draco}}==

byte i;

for i from 10 downto 0 do

write(i," ")

od

{{out}}

<pre>10 9 8 7 6 5 4 3 2 1 0</pre>

 

=={{header|DWScript}}==

 

=={{header|E}}==

 

 

=={{header|EasyLang}}==

 

print i

 

=={{header|EchoLisp}}==

(for ((longtemps-je-me-suis-couché-de-bonne-heure (in-range 10 -1 -1)))

(write longtemps-je-me-suis-couché-de-bonne-heure))

→ 10 9 8 7 6 5 4 3 2 1 0

 

=={{header|EDSAC order code}}==

Including a full routine to print integers in decimal would probably be overkill; at least, it would obscure what is essentially a simple program. We therefore cheat slightly by printing "10\r\n" manually, and using the loop only to print "9\r\n" down to "0\r\n". Note that character codes are stored in the high 5 bits of the 17-bit EDSAC word: so we actually count down from 36,864 to 0 in steps of 4,096.

==========================

 

[ 20 ] OF [ character c = '9' ]

 

 

=={{header|EGL}}==

SysLib.writeStdout( i );

 

=={{header|Ela}}==

===Standard Approach===

 

 

each [] = do return ()

each xs

 

 

===Alternative Approach===

 

 

countDown m n | n < m = do return ()

countDown m (n - 1)

 

 

=={{header|Elixir}}==

10

9

1

0

 

=={{header|Erlang}}==

-module(downward_loop).

-export([main/0]).

io:format("~p~n",[N])

end.

{{out}}

<pre>10

 

=={{header|ERRE}}==

FOR I%=10 TO 0 STEP -1 DO

PRINT(I%)

END FOR

 

=={{header|Euphoria}}==

? i

 

=={{header|F_Sharp|F#}}==

Using an enumerable expression:

 

Using the 'downto' keyword:

 

=={{header|Factor}}==

 

=={{header|FALSE}}==

 

=={{header|Fantom}}==

 

class DownwardFor

{

}

}

 

=={{header|Fermat}}==

 

=={{header|Forth}}==

Unlike the incrementing 10 0 DO-LOOP, this will print eleven numbers. The LOOP words detect crossing the floor of the end limit.

 

=={{header|Fortran}}==

{{Works with|Fortran|90 and later}}

WRITE(*, *) i

 

{{works with|Fortran|77 and later}}

C Initialize the loop parameters.

INTEGER I, START, FINISH, STEP

 

STOP

 

=={{header|Frink}}==

for i = 10 to 0 step -1

println[i]

 

=={{header|GAP}}==

Print(i, "\n");

 

=={{header|GML}}==

 

=={{header|Go}}==

fmt.Println(i)

 

import "fmt"

}

fmt.Println("blast off")

 

=={{header|Groovy}}==

println i

 

=={{header|Harbour}}==

? i

 

=={{header|Haskell}}==

 

main :: IO ()

 

=={{header|Haxe}}==

Haxe lacks a downward for-loop, but it is easy to create an iterator to serve that purpose.

 

var end:Int;

var step:Int;

}

}

 

{{out}}

 

=={{header|hexiscript}}==

println i

 

=={{header|HicEst}}==

WRITE() i

 

=={{header|HolyC}}==

for (i = 10; i >= 0; --i)

 

=={{header|Icon}} and {{header|Unicon}}==

There are four looping controls 'every', 'repeat', 'until', and 'while' (see [[Icon%2BUnicon/Intro#Looping_Controls|Introduction to Icon and Unicon/Looping Controls]] for more information.) The closest to a 'for' loop is 'every'.

# things to do within the loop

}

 

=={{header|IDL}}==

Using a loop (with an "increment of minus one" ):

 

 

But in IDL one would rarely use loops (for anything) since practically everything can be done with vectors/arrays.

The "IDL way of doing things" for the countdown requested in the task would probably be this:

 

 

=={{header|Inform 6}}==

 

=={{header|Io}}==

i println

 

=={{header|J}}==

J is array-oriented, so there is very little need for loops. For example, one could satisfy this task this way:

 

 

J does support loops for those times they can't be avoided (just like many languages support gotos for those time they can't be avoided).

for_i. i. - y do.

smoutput i

end.

 

Though it's rare to see J code like this.

That said, a convenient routine for generating intervals in J might be:

 

 

For example:

 

 

(or <code>,.10 thru 0</code> if you want each number on a line by itself)

 

=={{header|Java}}==

for (int i = 10; i >= 0; i--) {

System.out.println(i);

}

 

=={{header|JavaScript}}==

 

Alternatively, remaining for the moment within an imperative idiom of JavaScript, in which programs are composed of statements, we could trim the computational costs over longer reversed iterations by moving the mutation into the test, and dropping the third term of a for() statement:

 

 

and it sometimes might be more natural, especially at scales at which optimisation becomes an issue, to go one step further and express the same computation with the more economical while statement.

 

 

In a functional idiom of JavaScript, however, we need an expression with a value (which can be composed within superordinate expressions), rather than a statement, which produces a side-effect but returns no information-bearing value.

If we have grown over-attached to the English morpheme 'for', we might think first of turning to '''Array.forEach()''', and write something like:

 

return Array.apply(null, Array(n - m + 1)).map(

function (x, i) {

console.log(x);

}

 

 

We can get an expression (assuming that the range() function (above) is defined) but replacing Array.forEach with '''Array.map()'''

 

range(0, 10).reverse().map(

function (x) {

}

).join('\n')

 

but in this case, we are simply mapping an identity function over the values, so the expression simplifies down to:

 

range(0, 10).reverse().join('\n')

 

=={{header|jq}}==

If range/3 is available in your jq:

Otherwise:

range(-10;1) | -.

 

=={{header|Julia}}==

println(i)

 

=={{header|Kotlin}}==

// version 1.3.61

 

(10 downTo 0).forEach { println(it) }

}

 

=={{header|Lambdatalk}}==

{def downward_for

{lambda {:i}

{downward_for 10}

-> 10 9 8 7 6 5 4 3 2 1 0 (end of loop)

 

=={{header|langur}}==

writeln .i

 

writeln .i

 

=={{header|Lasso}}==

 

=={{header|Lhogho}}==

Slightly different syntax for <code>for</code> compared to Logo.

 

=={{header|Lingo}}==

put i

 

=={{header|Lisaac}}==

i.println;

 

=={{header|LiveCode}}==

Livecode's repeat "for" variant does not have a "down to" form, in a function you would need to manually decrement a counter

repeat for 10 times

put x & return

add -1 to x

 

A more idiomatic approach using "with" variant of repeat which does have a "down to" form

put n

 

=={{header|Logo}}==

If the limit is less than the start, then FOR decrements the control variable. Otherwise, a fourth parameter could be given as a custom increment.

 

=={{header|Lua}}==

for i=10,0,-1 do

print(i)

end

 

=={{header|M2000 Interpreter}}==

There is a slower For, the For Next style:

 

For i=1 to 10 step 2 : Print i : Next i

We have to use Exit For to exit from that type of For.

 

 

 

Form 80, 50

Module Checkit {

}

CheckIt

 

=={{header|M4}}==

`ifelse($#,0,``$0'',

`ifelse(eval($2 $3),1,

 

for(`x',`10',`>=0',`-1',`x

 

=={{header|Maple}}==

Using an explicit loop:

Pushing the loop into the kernel:

 

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

 

Using For:

Using Do:

Using Scan:

 

=={{header|MATLAB}} / {{header|Octave}}==

 

printf('%d\n',k)

 

A vectorized version of the code is

 

 

=={{header|Maxima}}==

 

=={{header|MAXScript}}==

 

=={{header|Mercury}}==

:- interface.

 

io.write_int(I, !IO), io.nl(!IO)

),

 

=={{header|Metafont}}==

 

 

The basic set of macros for Metafont defines <tt>downto</tt>, so that we can write

 

 

=={{header|min}}==

{{works with|min|0.19.6}}

Or

 

=={{header|MiniScript}}==

print i

 

=={{header|МК-61/52}}==

 

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

IMPORT InOut;

 

InOut.WriteLn

END

 

=={{header|Modula-3}}==

IO.PutInt(i);

 

=={{header|MUMPS}}==

NEW I FOR I=10:-1:1 WRITE I WRITE:I'=1 ", "

 

=={{header|Nemerle}}==

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols nobinary

 

say i_.right(2)

end i_

 

=={{header|NewLISP}}==

 

=={{header|Nim}}==

{{out}}

<pre>10

1

0</pre>

 

=={{header|Oberon-2}}==

Out.Int(i,0);

 

=={{header|Objeck}}==

for(i := 10; i >= 0; i--;) {

i->PrintLine();

};

 

=={{header|OCaml}}==

Printf.printf "%d\n" i

 

=={{header|Octave}}==

 

% ...

 

=={{header|Oforth}}==

 

 

=={{header|Oz}}==

{Show I}

 

=={{header|PARI/GP}}==

 

=={{header|Pascal}}==

 

=={{header|Peloton}}==

English fixed-length opcodes

 

Simplified Chinese variable-length opcodes

 

=={{header|Perl}}==

print "$_\n";

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">10</span> <span style="color: #008080;">to</span> <span style="color: #000000;">0</span> <span style="color: #008080;">by</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</span> <span style="color: #008080;">do</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">i</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

 

=={{header|PHP}}==

or

 

=={{header|PicoLisp}}==

or:

 

=={{header|Pike}}==

for(int i = 10; i >= 0; i--){

write(i + "\n");

}

 

=={{header|PL/I}}==

do i = 10 to 0 by -1;

put skip list (i);

end;

 

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

One way might be:

Start up.

Put 11 into a counter.

Subtract 1 from the counter.

If the counter is less than the number, say yes.

 

=={{header|Pop11}}==

for i from 10 by -1 to 0 do

printf(i, '%p\n');

 

=={{header|PowerShell}}==

$i

Alternatively, the range operator might be used as well which simply returns a contiguous range of integers:

 

=={{header|Prolog}}==

Although Prolog has a between(Lo,Hi,Value) iterator, there is no built in equivalent for iterating descending values. This is not a show stopper, as it's easy enough to write one.

rfor(Hi,Lo,Val) :- Hi > Lo, H is Hi - 1, !, rfor(H,Lo,Val).

 

reverse_iter :-

rfor(10,0,Val), write(Val), nl, fail.

<pre>?- reverse_iter.

10

 

=={{header|Python}}==

 

=== List comprehension ===

 

pprint.pprint([i for i in xrange(10, -1, -1)])

 

=={{header|Quackery}}==

 

 

{{Out}}

 

=={{header|R}}==

 

=={{header|Racket}}==

#lang racket

 

(for ([i (in-range 10 -1 -1)])

(displayln i))

 

=={{header|Raku}}==

{{works with|Rakudo Star|2010.08}}

 

.say;

 

=={{header|REBOL}}==

 

=={{header|Retro}}==

 

=={{header|REXX}}==

===version 1===

(equivalent to version 2 and version 3)

say j

 

===version 2===

(equivalent to version 1 and version 3)

say j

 

===version 3===

<br><br>Anybody who programs like this should be hunted down and shot like dogs!

<br><br>Hurrumph! Hurrumph!

say j

j=j+1 /*this increments the DO index. Do NOT program like this! */

 

===version 4===

This example isn't compliant to the task,

but it shows that the increment/decrement can be a non-integer:

say j

 

=={{header|Ring}}==

count from 10 to 0 by -1 step:

for i = 10 to 0 step -1 see i + nl next

 

=={{header|Ruby}}==

puts i

 

=={{header|Rust}}==

for i in (0..=10).rev() {

println!("{}", i);

}

 

=={{header|Salmon}}==

 

=={{header|Sather}}==

main is

i:INT;

end;

end;

 

=={{header|Scala}}==

//or

 

=={{header|Scheme}}==

((< i 0))

(display i)

 

=={{header|Scilab}}==

{{works with|Scilab|5.5.1}}

printf("%d\n",i)

{{out}}

<pre style="height:20ex">

 

=={{header|Seed7}}==

writeln(i);

 

=={{header|Sidef}}==

'''for(;;)''' loop:

say i

 

'''for-in''' loop:

say i

 

'''.each''' method:

say i

 

=={{header|Simula}}==

Integer i;

for i := 10 step -1 until 0 do

OutImage

END

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

aNumber displayNl.

].

10 downTo: 0 do:[:eachNumber |

eachNumber displayNl.

Both enumerate 10 to 0 inclusive.

 

Non-Smalltalkers might be confused when seeing:

eachNumber displayNl.

which has the same effect, but a slightly different mechanism.

 

 

The nice thing with Intervals is that they can be concatenated with a <tt>","</tt> operator (like all collections); thus, I could also write:

eachNumber displayNl.

to enumerate in a different order,

<br>or combine ranges with a constant array:

each displayNl.

or with a computed array:

each displayNl.

 

PS: there is also a reverse do, as in:

each displayNl.

 

=={{header|SNOBOL4}}==

LOOP OUTPUT = COUNT

COUNT = COUNT - 1

GE(COUNT, 0) :S(LOOP)

 

=={{header|SNUSP}}==

\n counter #\?>.</ \ @@@+@+++++# itoa

 

=={{header|Sparkling}}==

print(i);

 

=={{header|Spin}}==

{{works with|HomeSpun}}

{{works with|OpenSpin}}

_clkmode = xtal1 + pll16x

_clkfreq = 80_000_000

waitcnt(_clkfreq + cnt)

ser.stop

{{out}}

<pre>10 9 8 7 6 5 4 3 2 1 0</pre>

 

=={{header|SPL}}==

#.output(i)

 

=={{header|SSEM}}==

The SSEM can't print, so the results are stored in an array at addresses 22 to 31. Array access is done using self-modifying code: on each iteration we subtract the current value of <tt>n</tt> (stored at address 18) from the illegal instruction <tt>c to 32</tt>, yielding the actual instruction we use to store <tt>n</tt> into the array.

11001000000001100000000000000000 1. c to 19

11001000000000100000000000000000 2. -19 to c

11111111111111111111111111111111 16. -1

00000100000001100000000000000000 17. c to 32

 

=={{header|Stata}}==

See '''[https://www.stata.com/help.cgi?forvalues forvalues]''' and '''[https://www.stata.com/help.cgi?foreach foreach]''' in Stata help.

 

display `n'

}

foreach n of numlist 10/0 {

display `n'

 

=={{header|Swift}}==

println(i)

Alternately:

println(i)

In Swift 1.2 Alternately:

println(i)

Alternately (removed in Swift 3):

println(i)

Swift 3:

print(i)

 

=={{header|Tailspin}}==

Not really a for-loop, but it sends a stream of values where each gets treated the same way.

10..0:-1 -> '$;

' -> !OUT::write

 

=={{header|Tcl}}==

puts $i

}

 

=={{header|Trith}}==

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

LOOP n=10,0,-1

PRINT n

ENDLOOP

 

=={{header|UNIX Shell}}==

{{works with|Bourne Shell}}

while test $i -ge 0; do

echo $i

# or

 

 

----

{{works with|bash}}

echo $Z

done

echo $Z

done

 

=={{header|UnixPipes}}==

{{works with|OpenBSD|4.9}}

expr $n - 1

 

This pipe uses several nonstandard commands: <code>cat -n</code> and <code>tail -r</code> might not work with some systems.

 

=={{header|Ursa}}==

for (set i 10) (> i -1) (dec i)

out i endl console

 

=={{header|V}}==

[0 >]

[dup puts pred]

 

=={{header|Vala}}==

 

=={{header|Vedit macro language}}==

Num_Type(#1)

 

=={{header|Verilog}}==

module main;

integer i;

end

endmodule

 

for i := 10; i >= 0; i-- {

print('$i ')

}

 

{{out}}

 

=={{header|Wart}}==

 

=={{header|Wren}}==

 

{{out}}

 

=={{header|XPL0}}==

int I;

for I:= 10 downto 0 do

 

=={{header|zkl}}==

[10..0,-1].apply() //-->L(10,9,8,7,6,5,4,3,2,1,0)

// tail recursion