Loops/Downward for

Write a for loop which writes a countdown from 10 to 0.

360 Assembly

Use of BXLE and BCT opcodes. <lang 360asm>* Loops/Downward for 27/07/2015 LOOPDOWN CSECT

        USING  LOOPDOWN,R12
        LR     R12,R15            set base register

BEGIN EQU *

fisrt loop with a BXLE BXLE: Branch on indeX Low or Equal

        LH     R2,=H'11'          from 10 (R2=11) index
        LH     R4,=H'-1'          step -1 (R4=-1)
        LH     R5,=H'-1'          to 0    (R5=-1)

LOOPI BXLE R2,R4,ELOOPI R2=R2+R4 if R2<=R5 goto ELOOPI

        XDECO  R2,BUFFER          edit R2
        XPRNT  BUFFER,L'BUFFER    print    
        B      LOOPI

ELOOPI EQU *

second loop with a BCT BCT: Branch on CounT

        LA     R2,10              index   R2=10
        LA     R3,11              counter R3=11

LOOPJ XDECO R2,BUFFER edit R2

        XPRNT  BUFFER,L'BUFFER    print
        BCTR   R2,0               R2=R2-1

ELOOPJ BCT R3,LOOPJ R3=R3-1 if R3<>0 goto LOOPI RETURN XR R15,R15 set return code

        BR     R14                return to caller

BUFFER DC CL80' '

        YREGS  
        END    LOOPDOWN</lang>

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. <lang 6502asm>;An OS/hardware specific routine that is setup to display the Ascii character

value contained in the Accumulator

Send = $9000 ;routine not implemented here PrintNewLine = $9050 ;routine not implemented here

 		*= 	$8000		;set base address

Start PHA ;push Accumulator and Y register onto stack TYA PHA LDY #10 ;set Y register to loop start value TYA ;place loop value in the Accumulator Loop JSR PrintTwoDigits JSR PrintNewLine DEY ;decrement loop value BPL Loop ;continue loop if sign flag is clear PLA ;pop Y register and Accumulator off of stack TAY PLA RTS ;exit

Print value in Accumulator as two hex digits

PrintTwoDigits PHA LSR LSR LSR LSR JSR PrintDigit PLA AND #$0F JSR PrintDigit RTS

Convert value in Accumulator to an Ascii hex digit

PrintDigit ORA #$30 JSR Send ;routine not implemented here RTS </lang>

Ada

<lang ada>for I in reverse 0..10 loop

  Put_Line(Integer'Image(I));

end loop;</lang>

ALGOL 68

Works with: ALGOL 68 version Standard - no extensions to language used

Works with: ALGOL 68G version Any - tested with release mk15-0.8b.fc9.i386

Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386

<lang algol68>FOR i FROM 10 BY -1 TO 0 DO

   print((i,new line))

OD</lang> 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. <lang algol68>FOR i FROM 10 DOWNTO 0 DO

   print((i,new line))

OD</lang>

ALGOL W

<lang algolw>begin

   for i := 10 step -1 until 0 do
   begin
       write( i )
   end

end.</lang>

AmigaE

<lang amigae>PROC main()

 DEF i
 FOR i := 10 TO 0 STEP -1
   WriteF('\d\n', i)
 ENDFOR

ENDPROC</lang>

AppleScript

<lang AppleScript>repeat with i from 10 to 0 by -1

 log i

end repeat</lang>

AutoHotkey

<lang AutoHotkey>x := 10 While (x >= 0) {

 output .= "`n" . x
 x--

} MsgBox % output </lang>

AWK

<lang awk>BEGIN {

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

}</lang>

Axe

Axe does not support for loops with step sizes other than 1. <lang axe>For(I,0,10)

Disp 10-I▶Dec,i

End</lang>

BASIC

<lang qbasic>for i = 10 to 0 step -1

  print i

next i</lang>

Applesoft BASIC

<lang ApplesoftBasic>FOR I = 10 TO 0 STEP -1 : PRINT I : NEXT I</lang>

Batch File

BBC BASIC

<lang bbcbasic> FOR i% = 10 TO 0 STEP -1

       PRINT i%
     NEXT</lang>

bc

Befunge

Bracmat

Brat

C

<lang c>int i; for(i = 10; i >= 0; --i)

 printf("%d\n",i);</lang>

C++

<lang cpp>for(int i = 10; i >= 0; --i)

 std::cout << i << "\n";</lang>

C#

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

  Console.WriteLine(i);

}</lang>

Ceylon

<lang ceylon>for (i in 10..0) {

   print(i);

}</lang>

Clojure

<lang csharp>(doseq [x (range 10 -1 -1)] (println x))</lang>

COBOL

free-form <lang cobol>identification division. program-id. countdown. environment division. data division. working-storage section. 01 counter pic 99. 88 counter-done value 0. 01 counter-disp pic Z9. procedure division. perform with test after varying counter from 10 by -1 until counter-done move counter to counter-disp display counter-disp end-perform stop run.</lang>

Output:

CoffeeScript

This could be written either in the array comprehension style, or in "regular" for loop style. <lang coffeescript># The more compact "array comprehension" style console.log i for i in [10..0]

The "regular" for loop style.

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

More compact version of the above

for i in [10..0] then console.log i</lang>

(the output is repeated three times; once for each loop)

ColdFusion

With tags: <lang cfm><cfloop index = "i" from = "10" to = "0" step = "-1">

#i#

</cfloop></lang> With script: <lang cfm><cfscript>

 for( i = 10; i <= 0; i-- )
 {
   writeOutput( i );
 }

</cfscript></lang>

Common Lisp

<lang lisp>(loop for i from 10 downto 1 do

 (print i))</lang>

Chapel

<lang chapel>for i in 1..10 by -1 do writeln(i);</lang>

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

Clipper

<lang clipper> FOR i := 10 TO 0 STEP -1

     ? i
  NEXT</lang>

D

<lang d>import std.stdio: writeln;

void main() {

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

   foreach_reverse (i ; 0 .. 10 + 1)
       writeln(i);

}</lang>

Output:

dc

does not use GNU extensions

[]s. is a comment

c clears the stack

[~...]p s. to print strings

l<register>x executes the macro

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

<lang dc>c

[macro s(swap) - (a b : b a)]s. [Sa Sb La Lb] ss

[macro d(2dup) - (a b : a b a b)]s. [Sa d Sb La d Lb lsx] sd

[macro m(for) - ]s. [lfx 1 - ldx !<m ] sm

0 10 ldx [p] sf !<m q</lang>

Using it <lang dc>|dc < ./for.dc 10 9 ... 0</lang>

Delphi

See Pascal

DWScript

<lang pascal>for i := 10 downto 0 do

 PrintLn(i);</lang>

E

<lang e>for i in (0..10).descending() { println(i) }</lang>

EchoLisp

<lang scheme> (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

</lang>

EGL

<lang EGL>for ( i int from 10 to 0 decrement by 1 )

  SysLib.writeStdout( i );

end</lang>

Elixir

<lang elixir>iex(1)> Enum.each(10..0, fn i -> IO.puts i end) 10 9 8 7 6 5 4 3 2 1 0

ok</lang>

Erlang

<lang erlang>%% Implemented by Arjun Sunel -module(downward_loop). -export([main/0]).

main() -> for_loop(10).

for_loop(N) ->
	if N > 0 ->

io:format("~p~n",[N] ), for_loop(N-1); true -> io:format("~p~n",[N]) end. </lang>

Output:

ERRE

  FOR I%=10 TO 0 STEP -1 DO
    PRINT(I%)
  END FOR

</lang>

Euphoria

<lang euphoria>for i = 10 to 0 by -1 do

? i

end for</lang>

Ela

Standard Approach

<lang ela>open monad io

each [] = do return () each (x::xs) = do

 putStrLn $ show x
 each xs

each [10,9..0] ::: IO</lang>

Alternative Approach

<lang ela>open monad io

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

             | else = do
                 putStrLn $ show n
                 countDown m (n - 1)

_ = countDown 0 10 ::: IO</lang>

Factor

FALSE

Fantom

<lang fantom> class DownwardFor {

 public static Void main ()
 {
   for (Int i := 10; i >= 0; i--)
   {
     echo (i)
   }
 }

} </lang>

FBSL

<lang qbasic>#APPTYPE CONSOLE

FOR DIM i = 10 DOWNTO 0

   PRINT i

Forth

Unlike the incrementing 10 0 DO-LOOP, this will print eleven numbers. The LOOP words detect crossing the floor of the end limit. <lang forth>: loop-down 0 10 do i . -1 +loop ;</lang>

Fortran

Works with: Fortran version 90 and later

<lang fortran>DO i = 10, 0, -1

 WRITE(*, *) i

END DO</lang>

Works with: Fortran version 77 and later

<lang fortran> PROGRAM DOWNWARDFOR C Initialize the loop parameters.

       INTEGER I, START, FINISH, STEP
       PARAMETER (START = 10, FINISH = 0, STEP = -1)

C If you were to leave off STEP, it would default to positive one.

       DO 10 I = START, FINISH, STEP
         WRITE (*,*) I
  10   CONTINUE

       STOP
     END</lang>

Frink

<lang frink> for i = 10 to 0 step -1

  println[i]

</lang>

F#

Using an enumerable expression: <lang fsharp>for i in 10..-1..0 do

 printfn "%d" i</lang>

Using the 'downto' keyword: <lang fsharp>for i = 10 downto 0 do

 printfn "%d" i</lang>

GAP

<lang gap>for i in [10, 9 .. 0] do

   Print(i, "\n");

od;</lang>

GML

<lang GML>for(i = 10; i >= 0; i -= 1)

   show_message(string(i))</lang>

Go

<lang go>for i := 10; i >= 0; i-- {

 fmt.Println(i)

}</lang>

Groovy

<lang groovy>for (i in (10..0)) {

   println i

}</lang>

Harbour

<lang visualfoxpro>FOR i := 10 TO 0 STEP -1

? i

NEXT</lang>

Haskell

<lang haskell>import Control.Monad forM_ [10,9..0] print</lang>

HicEst

<lang hicest>DO i = 10, 0, -1

 WRITE() i

ENDDO</lang>

IDL

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

<lang idl>for i=10,0,-1 do print,i</lang>

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:

<lang idl>print,10-indgen(11)</lang>

Icon and Unicon

There are four looping controls 'every', 'repeat', 'until', and 'while' (see Introduction to Icon and Unicon/Looping Controls for more information.) The closest to a 'for' loop is 'every'. <lang Icon>every i := 10 to 0 by -1 do {

  # things to do within the loop
  }

</lang>

Inform 6

<lang Inform 6>for(i = 10: i >= 0: i--)

   print i, "^";</lang>

J

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

  ,. i. -11

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). <lang j>3 : 0 ] 11

 for_i. i. - y do.
   smoutput i
 end.

)</lang>

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 ,.10 thru 0 if you want each number on a line by itself)

This verb "thru" will count up or down, starting and stop at the indicated left and right ending points.

Java

<lang java>for(i = 10; i >= 0; --i){

  System.out.println(i);

}</lang>

JavaScript

<lang javascript>for (var i=10; i>=0; --i) print(i);</lang>

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:

<lang JavaScript>for (var i = 11; i--;) console.log(i);</lang>

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.

<lang JavaScript>var i = 11; while (i--) console.log(i);</lang>

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:

<lang JavaScript>function range(m, n) {

 return Array.apply(null, Array(n - m + 1)).map(
   function (x, i) {
     return m + i;
   }
 );

}

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

 function (x) {
   console.log(x);
 }

);</lang>

but this is still a statement with side-effects, rather than a composable expression with a value.

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

<lang JavaScript>console.log(

 range(0, 10).reverse().map(
   function (x) {
     return x;
   }
 ).join('\n')

);</lang>

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

<lang JavaScript>console.log(

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

);</lang>

jq

If range/3 is available in your jq: <lang jq>range(10;-1;-1)</lang> Otherwise:

range(-10;1) | -.

Julia

<lang julia>for i in 10:-1:0

   println(i)

end</lang>

Lasso

<lang Lasso>loop(-from=10, -to=0, -by=-1) => {^ loop_count + ' ' ^}</lang>

Lhogho

Slightly different syntax for for compared to Logo. <lang logo>for "i [10 0] [print :i]</lang>

Liberty BASIC

<lang lb> for i = 10 to 0 step -1

  print i

next i end </lang>

Lisaac

<lang Lisaac>10.downto 0 do { i : INTEGER;

 i.println;

};</lang>

LiveCode

Livecode's repeat "for" variant does not have a "down to" form, in a function you would need to manually decrement a counter <lang LiveCode>local x=10 repeat for 10 times

 put x & return                                                                                                        
 add -1 to x

end repeat</lang>

A more idiomatic approach using "with" variant of repeat which does have a "down to" form <lang LiveCode>repeat with n=10 down to 1

 put n

end repeat</lang>

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. <lang logo>for [i 10 0] [print :i]</lang>

Lua

<lang lua> for i=10,0,-1 do

 print(i)

end </lang>

M4

<lang M4>define(`for',

  `ifelse($#,0,``$0,
  `ifelse(eval($2 $3),1,
  `pushdef(`$1',$2)$5`'popdef(`$1')$0(`$1',eval($2+$4),$3,$4,`$5')')')')dnl

for(`x',`10',`>=0',`-1',`x ')</lang>

Maple

Using an explicit loop: <lang Maple>for i from 10 to 0 by -1 do print(i) end:</lang> Pushing the loop into the kernel: <lang Maple>seq(print(i),i=10..0,-1)</lang>

Mathematica

Mathematica provides several ways to iterate over a range of numbers, small subtle differences are amongst them. 3 possible implementations are (exactly the same output):

Using For: <lang Mathematica>For[i = 10, i >= 0, i--, Print[i]]</lang> Using Do: <lang Mathematica>Do[Print[i], {i, 10, 0, -1}]</lang> Using Scan: <lang Mathematica>Scan[Print, Range[10, 0, -1]]</lang>

MATLAB / Octave

<lang Matlab> for k = 10:-1:0,

       printf('%d\n',k)
   end; </lang>

A vectorized version of the code is

<lang Matlab> printf('%d\n',10:-1:0); </lang>

Maxima

<lang maxima>for i from 10 thru 0 step -1 do print(i);</lang>

MAXScript

<lang maxscript>for i in 10 to 0 by -1 do print i</lang>

Mercury

<lang>:- module loops_downward_for.

- interface.

- import_module io.

- pred main(io::di, io::uo) is det.

- implementation.

- import_module int.

main(!IO) :-

  Print = (pred(I::in, !.IO::di, !:IO::uo) is det :-
      io.write_int(I, !IO), io.nl(!IO)
  ),
  int.fold_down(Print, 1, 10, !IO).</lang>

Metafont

<lang metafont>for i = 10 step -1 until 0: show i; endfor end</lang>

The basic set of macros for Metafont defines downto, so that we can write

<lang metafont>for i = 10 downto 0: show i; endfor end</lang>

МК-61/52

Modula-2

<lang modula2>MODULE Downward;

 IMPORT InOut;

 VAR
   i: INTEGER;

BEGIN

 FOR i := 10 TO 0 BY -1 DO
   InOut.WriteInt(i, 2);
   InOut.WriteLn
 END

END Downward.</lang>

Modula-3

<lang modula3>FOR i := 10 TO 0 BY -1 DO

 IO.PutInt(i);

END;</lang>

MUMPS

<lang MUMPS>LOOPDOWN

NEW I FOR I=10:-1:1 WRITE I WRITE:I'=1 ", "
KILL I QUIT</lang>

NewLISP

<lang NewLISP>(for (i 10 0)

 (println i))</lang>

Nim

<lang nim>for x in countdown(10,0): echo(x)</lang>

Output:

Nemerle

<lang Nemerle>for (i = 10; i >= 0; i--) {WriteLine($"$i")}</lang> <lang Nemerle>foreach (i in [10, 9 .. 0]) {WriteLine($"$i")}</lang>

NetRexx

<lang NetRexx>/* NetRexx */ options replace format comments java crossref savelog symbols nobinary

 say
 say 'Loops/Downward for'

 loop i_ = 10 to 0 by -1
   say i_.right(2)
   end i_

</lang>

Oberon-2

<lang oberon2>FOR i := 10 TO 0 BY -1 DO

 Out.Int(i,0);

END;</lang>

Objeck

<lang objeck> for(i := 10; i >= 0; i -= 1;) {

  i->PrintLine();

}; </lang>

OCaml

<lang ocaml>for i = 10 downto 0 do

 Printf.printf "%d\n" i

done</lang>

Octave

<lang octave>for i = 10:-1:0

 % ...

endfor</lang>

Oforth

<lang Oforth>10 0 -1 step: i [ i println ]</lang>

Oz

<lang oz>for I in 10..0;~1 do

  {Show I}

end</lang>

PARI/GP

<lang parigp>forstep(n=10,0,-1,print(n))</lang>

Pascal

<lang pascal>for i := 10 downto 0 do

 writeln(i);</lang>

Peloton

English fixed-length opcodes <lang sgml><@ ITEFORLITLITLITLIT>0|<@ SAYVALFOR>...</@>|10|-1</@></lang>

Simplified Chinese variable-length opcodes <lang sgml><# 迭代迭代次数字串字串字串字串>0|<# 显示值迭代次数>...</#>|10|-1</#></lang>

Perl

<lang perl>foreach (reverse 0..10) {

 print "$_\n";

}</lang>

Perl 6

Works with: Rakudo Star version 2010.08

<lang perl6>for 10 ... 0 {

   .say;

}</lang>

Phix

<lang Phix>for i=10 to 0 by -1 do

?i

end for</lang>

PHP

<lang php>for ($i = 10; $i >= 0; $i--)

 echo "$i\n";</lang>

or <lang php>foreach (range(10, 0) as $i)

 echo "$i\n";</lang>

PicoLisp

<lang PicoLisp>(for (I 10 (ge0 I) (dec I))

  (println I) )</lang>

or: <lang PicoLisp>(mapc println (range 10 0))</lang>

Pike

<lang pike>int main(){

  for(int i = 10; i >= 0; i--){
     write(i + "\n");
  }

}</lang>

PL/I

<lang PL/I> do i = 10 to 0 by -1;

  put skip list (i);

end; </lang>

Pop11

<lang pop11>lvars i; for i from 10 by -1 to 0 do

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

endfor;</lang>

PowerShell

<lang powershell>for ($i = 10; $i -ge 0; $i--) {

$i

}</lang> Alternatively, the range operator might be used as well which simply returns a contiguous range of integers: <lang powershell>10..0</lang>

PureBasic

<lang PureBasic>For i=10 To 0 Step -1

 Debug i

Next</lang>

Python

<lang python>for i in xrange(10, -1, -1):

   print i</lang>

List comprehension

<lang python>[i for i in xrange(10, -1, -1)]</lang> <lang python>import pprint pprint.pprint([i for i in xrange(10, -1, -1)]) </lang>

R

<lang R>for(i in 10:0) {print(i)}</lang>

Racket

lang racket

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

 (displayln i))

</lang>

REBOL

<lang REBOL>for i 10 0 -1 [print i]</lang>

Retro

<lang Retro>11 [ putn space ] iterd</lang>

REXX

version 1

(equivalent to version 2 and version 3) <lang rexx> do j=10 to 0 by -1

 say j
 end</lang>

version 2

(equivalent to version 1 and version 3) <lang rexx> do j=10 by -1 to 0

 say j
 end</lang>

version 3

(equivalent to version 1 and version 2)

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

Hurrumph! Hurrumph! <lang rexx> do j=10 by -2 to 0

 say j
 j=j+1     /*this increments the  DO  index.   Do NOT program like this! */
 end</lang>

version 4

This example isn't compliant to the task, but it shows that the increment/decrement can be a non-integer: <lang rexx> do j=30 to 1 by -.25

 say j
 end</lang>

Ring

count from 10 to 0 by -1 step: <lang ring> for i = 10 to 0 step -1 see i + nl next </lang>

Ruby

<lang ruby>10.downto(0) do |i|

  puts i

end</lang>

Rust

<lang rust>fn main() {

   for i in (1..10+1).rev() {
       println!("{}", i);
   }

}</lang>

Salmon

<lang Salmon>for (x; 10; x >= 0; -1)

   x!;</lang>

Sather

<lang sather>class MAIN is

 main is
   i:INT;
   loop i := 10.downto!(0);
      #OUT  + i + "\n";
   end;
 end;

end;</lang>

Scala

Scheme

<lang scheme>(do ((i 10 (- i 1)))

   ((< i 0))
   (display i)
   (newline))</lang>

Seed7

<lang seed7>for i range 10 downto 0 do

 writeln(i);

end for;</lang>

Scilab

Works with: Scilab version 5.5.1

<lang>for i=10:-1:0

   printf("%d\n",i)

end</lang>

Output:

Sidef

for(;;) loop: <lang ruby>for (var i = 10; i >= 0; i--) {

   say i

}</lang>

for-in loop: <lang ruby>for i in (10 ^.. 0) {

   say i

}</lang>

.each method: <lang ruby>10.downto(0).each { |i|

   say i

}</lang>

Slate

<lang slate>10 downTo: 1 do: [| :n | print: n]</lang>

Smalltalk

<lang smalltalk>10 to: 1 by: -1 do:[:aNumber |

 aNumber display.
 Character space display.

]</lang>

SNUSP

<lang snusp>++++++++++>++++++++++!/- @!\=@\.@@@-@-----# atoi

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

Sparkling

<lang sparkling>for var i = 10; i >= 0; i-- {

   print(i);

}</lang>

Swift

<lang swift>for i in stride(from: 10, through: 0, by: -1) {

 println(i)

}</lang> Alternately: <lang swift>for i in lazy(0...10).reverse() {

 println(i)

}</lang> In Swift 1.2 Alternately: <lang swift>for i in reverse(0 ... 10) {

 println(i)

}</lang> Alternately (removed in Swift 3): <lang swift>for var i = 10; i >= 0; i-- {

 println(i)

}</lang>

Tcl

<lang tcl>for {set i 10} {$i >= 0} {incr i -1} {

   puts $i

}

puts "We have liftoff!"</lang>

TI-83 BASIC

For(I,10,0,-1

Disp I

End

</lang>

TI-89 BASIC

<lang ti89b>Local i For i, 10, 0, –1

 Disp i

EndFor</lang>

Trith

<lang trith>10 inc iota reverse [print] each</lang> <lang trith>10 [dup print dec] [dup 0 >=] while drop</lang>

TUSCRIPT

<lang tuscript> $$ MODE TUSCRIPT LOOP n=10,0,-1

PRINT n

ENDLOOP </lang>

UnixPipes

Works with: OpenBSD version 4.9

<lang bash>yes | cat -n | head -n 11 | while read n; do expr $n - 1 done | tail -r</lang>

This pipe uses several nonstandard commands: cat -n and tail -r might not work with some systems. If there is no tail -r, try tac.

UNIX Shell

Works with: Bourne Shell

<lang bash>i=10 while test $i -ge 0; do echo $i i=`expr $i - 1` done</lang>

Works with: bash

<lang bash>for(( Z=10; Z>=0; Z-- )); do

   echo $Z

done</lang>

Works with: Bourne Shell

Library: jot

Works with: Bourne Shell

<lang bash>for i in `seq 10 -1 0`; do echo $i done

or better yet

seq 10 -1 0 </lang>

V

<lang v>10 [0 >]

 [dup puts pred]

while</lang>

Vedit macro language

<lang vedit>for (#1 = 10; #1 >= 0; #1--) {

   Num_Type(#1)

}</lang>

Visual Basic .NET

<lang vbnet>For i = 10 To 0 Step -1

   Console.WriteLine(i)

Next</lang>

Wart

<lang>for i 10 (i >= 0) --i

 prn i</lang>

XPL0

<lang XPL0>include c:\cxpl\codes; \intrinsic 'code' declarations int I; for I:= 10 downto 0 do

       [IntOut(0, I); CrLf(0)]</lang>

zkl

<lang zkl>foreach n in ([10..0,-1]){ println(n) } [10..0,-1].apply() //-->L(10,9,8,7,6,5,4,3,2,1,0)

  // tail recursion

fcn(n){ n.println(); if(n==0)return(); return(self.fcn(n-1)) }(10)</lang>

ZX Spectrum Basic

<lang zxbasic>10 FOR l = 10 TO 0 STEP -1 20 PRINT l 30 NEXT l</lang>