Loops/Downward for
You are encouraged to solve this task according to the task description, using any language you may know.
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
<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>
Applesoft BASIC
<lang ApplesoftBasic>FOR I = 10 TO 0 STEP -1 : PRINT I : NEXT I</lang>
BBC BASIC
<lang bbcbasic> FOR i% = 10 TO 0 STEP -1
PRINT i% NEXT</lang>
bc
<lang bc>for (i = 10; i >= 0; i--) i quit</lang>
Befunge
<lang befunge>55+>:.:v
^ -1_@</lang>
Bracmat
<lang bracmat> 10:?i & whl'(out$!i&!i+-1:~<0:?i)</lang>
Brat
<lang brat>10.to 0 { n | p n }</lang>
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>
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
10 9 8 7 6 5 4 3 2 1 0
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>
10 9 8 7 6 5 4 3 2 1 0
(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
<lang chapel>var r = 1..10; for i in r by -1 do { ... }</lang>
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:
10 9 8 7 6 5 4 3 2 1 0 10 9 8 7 6 5 4 3 2 1 0
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>
EGL
<lang EGL>for ( i int from 10 to 0 decrement by 1 )
SysLib.writeStdout( i );
end</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:
10 9 8 7 6 5 4 3 2 1 0 ok
Euphoria
<lang euphoria>for i = 10 to 0 by -1 do
? i
end for</lang>
Ela
Standard Approach
<lang ela>open console imperative
each writen [10,9..0]</lang>
Function 'each' is defined in imperative module as:
<lang ela> each f (x::xs) = f x $ each f xs each _ [] = ()</lang>
Alternative Approach
<lang ela>open console
countDown m n | n < m = ()
| else = writen n $ countDown m (n-1)
countDown 0 10</lang>
Factor
<lang factor>11 iota <reversed> [ . ] each</lang>
FALSE
<lang false>10[$0>][$." "1-]#.</lang>
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
NEXT
PAUSE </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
<lang fortran>DO i = 10, 0, -1
WRITE(*, *) i
END DO</lang>
<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 harbour> 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. i 1!:2 ]2 end. i.0 0 )</lang>
Though it's rare to see J code like this.
That said, a convenient routine for generating intervals in J might be:
<lang J>thru=: <./ + i.@(+*)@-~</lang>
For example:
<lang J> 10 thru 0 10 9 8 7 6 5 4 3 2 1 0</lang>
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>
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>
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
<lang>1 0 П0 ИП0 L0 03 С/П</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>
Nimrod
<lang nimrod>for x in countdown(10,0): echo(x)</lang>
- Output:
10 9 8 7 6 5 4 3 2 1 0
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
<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>
Protium
English fixed-length opcodes <lang xml><@ ITEFORLITLITLITLIT>0|<@ SAYVALFOR>...</@>|10|-1</@></lang>
Simplified Chinese variable-length opcodes <lang xml><# 迭代迭代次数字串字串字串字串>0|<# 显示值迭代次数>...</#>|10|-1</#></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>
- 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>
Ruby
<lang ruby>10.downto(0) do |i|
puts i
end</lang>
Rust
<lang rust>// rust 0.9-pre
fn main() {
for i in std::iter::range_inclusive(0, 10).invert() { 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
<lang scala>for(i <- 10 to 0 by -1) println(i) //or 10 to 0 by -1 foreach println</lang>
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
<lang ti83b>
- 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
<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
<lang bash>i=10 while test $i -ge 0; do echo $i i=`expr $i - 1` done</lang>
<lang bash>for(( Z=10; Z>=0; Z-- )); do
echo $Z
done</lang>
<lang bash>for i in `jot - 10 0 -1`; do echo $i done</lang>
<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>
ZX Spectrum Basic
<lang zxbasic>10 FOR l = 10 TO 0 STEP -1 20 PRINT l 30 NEXT l</lang>
- Programming Tasks
- Iteration
- 6502 Assembly
- Ada
- ALGOL 68
- AmigaE
- AutoHotkey
- AWK
- BASIC
- Applesoft BASIC
- BBC BASIC
- Bc
- Befunge
- Bracmat
- Brat
- C
- C++
- C sharp
- Clojure
- COBOL
- CoffeeScript
- ColdFusion
- Common Lisp
- Chapel
- Clipper
- D
- Dc
- Delphi
- DWScript
- E
- EGL
- Erlang
- Euphoria
- Ela
- Factor
- FALSE
- Fantom
- FBSL
- Forth
- Fortran
- Frink
- F Sharp
- GAP
- GML
- Go
- Groovy
- Harbour
- Haskell
- HicEst
- IDL
- Icon
- Unicon
- Inform 6
- J
- Java
- JavaScript
- Julia
- Lasso
- Lhogho
- Liberty BASIC
- Lisaac
- Logo
- Lua
- M4
- Maple
- Mathematica
- MATLAB
- Octave
- Maxima
- MAXScript
- Mercury
- Metafont
- МК-61/52
- Modula-2
- Modula-3
- MUMPS
- Nimrod
- Nemerle
- NetRexx
- Oberon-2
- Objeck
- OCaml
- Oz
- PARI/GP
- Pascal
- Perl
- Perl 6
- PHP
- PicoLisp
- Pike
- PL/I
- Pop11
- PowerShell
- Protium
- PureBasic
- Python
- R
- Racket
- REBOL
- Retro
- REXX
- Ruby
- Rust
- Salmon
- Sather
- Scala
- Scheme
- Seed7
- Slate
- Smalltalk
- SNUSP
- Tcl
- TI-83 BASIC
- TI-89 BASIC
- Trith
- TUSCRIPT
- UnixPipes
- UNIX Shell
- Jot
- V
- Vedit macro language
- Visual Basic .NET
- Wart
- XPL0
- ZX Spectrum Basic