Loops/Downward for

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

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. <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>

AmigaE

<lang amigae>PROC main()

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

ENDPROC</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>

BASIC

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

  print i

next i</lang>

bc

Befunge

<lang befunge>55+>:.:v

  ^ -1_@</lang>

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>

Clojure

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

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>

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>

Euphoria

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

? i

end for</lang>

Ela

Standard Approach

<lang ela>open Console open Imperative

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

Function 'each' is defined in standard Imperative module as:

<lang ela>let each f (x::xs) = f x $ each f xs

   each _ []      = ()</lang>

Alternative Approach

<lang ela>open Console

let countDown m n | n < m = ()

                 | else = writen n $ countDown m (n-1)

countDown 0 10</lang>

Factor

FALSE

Fantom

<lang fantom> class DownwardFor {

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

} </lang>

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>

F#

<lang fsharp>for i in 10..-1..0 do

 printfn "%d" i</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>

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.
           i 1!:2 ]2 
       end.
    i.0 0
  )</lang>

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

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

R

<lang R>for(i in 10:0) {print(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>

Ruby

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

  puts i

end</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>

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>

Tcl

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

   puts $i

}

puts "We have liftoff!"</lang>

TI-83 BASIC

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>

ZX Spectrum Basic

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