Loops/Downward for

Task

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

Related tasks

11l

L(i) (10..0).step(-1)
   print(i)

360 Assembly

Use of BXLE and BCT opcodes.

*        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

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.

;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

68000 Assembly

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

ForLoop:
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
rts

8080 Assembly

This assumes the CP/M operating system.

	;-------------------------------------------------------
	; some useful equates
	;-------------------------------------------------------
bdos	equ	5h	; location ofjump to BDOS entry point
wboot   equ     0       ; BDOS warm boot function
conout  equ     2       ; write character to console
	;-------------------------------------------------------
	; main code
	;-------------------------------------------------------
	org	100h
	lxi	sp,stack  ; set up a stack
	;
	lxi	h,10	; starting value for countdown 
loop:	call	putdec	; print it
	mvi	a,' '	; space between numbers
	call	putchr
	dcx	h	; decrease count by 1 
	mov	a,h	; are we done (HL = 0)?
	ora	l
	jnz	loop	; no, so continue with next number
	jmp	wboot	; otherwise exit to operating system
	;-------------------------------------------------------
	; console output of char in A register
	; preserves BC, DE, HL
	;-------------------------------------------------------
putchr:	push	h
	push	d
	push	b
	mov	e,a
	mvi	c,conout
	call	bdos
	pop	b
	pop	d
	pop	h
	ret
	;---------------------------------------------------------
	; Decimal output to console routine
	; HL holds 16-bit unsigned binary number to print
	; Preserves BC, DE, HL
	;---------------------------------------------------------
putdec: push	b
	push	d
	push	h
	lxi	b,-10
	lxi	d,-1
putdec2:
	dad	b
	inx	d
	jc	putdec2
	lxi	b,10
	dad	b
	xchg
	mov	a,h
	ora	l
	cnz	putdec		; recursive call!
	mov	a,e
	adi	'0'		; make printable
	call	putchr
	pop	h
	pop	d
	pop	b
	ret
	;----------------------------------------------------------
	;  data area
	;----------------------------------------------------------
stack	equ	$+128	; 64-level stack to support recursion
	;
	end

Output:

10 9 8 7 6 5 4 3 2 1

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 LOOP instruction will loop a section of code, using the CX register as the loop counter.

       .model small ;.exe file, max 128 KB
       .stack 1024  ;reserve 1 KB for the stack pointer.
       
       .data
       
       ;no data needed

       .code
start:
	
	mov ax,0100h	;UNPACKED BCD "10"
	mov cx,0Bh	;loop counter
	
repeat_countdown:
	call PrintBCD_IgnoreLeadingZeroes
	sub ax,1
	aas			
	;ascii adjust for subtraction, normally 0100h - 1 = 0FFh but this corrects it to 0009h
	push ax
		mov dl,13
		mov ah,02h
		int 21h
		
		mov dl,10
		mov ah,02h
		int 21h
		;these 6 lines of code are the "new line" function
	pop ax
	loop repeat_countdown ;decrement CX and jump back to the label "repeat_countdown" if CX != 0
	
	

	mov ax,4C00h
	int 21h			;return to DOS

PrintBCD_IgnoreLeadingZeroes:
	push ax
		cmp ah,0
		jz skipLeadingZero
			or ah,30h         ;convert a binary-coded decimal quantity to an ASCII numeral
			push dx
			push ax
				mov al,ah
				mov ah,0Eh
				int 10h	   ;prints AL to screen
			pop ax
			pop dx
skipLeadingZero:
		or al,30h
		push dx
		push ax
			mov ah,0Eh
			int 10h		   
		pop ax
		pop dx
	pop ax
	ret

        end start ;EOF

AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits

/* ARM assembly AARCH64 Raspberry PI 3B */
/*  program loopdownward64.s   */

/*******************************************/
/* Constantes file                         */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
 
/*********************************/
/* Initialized data              */
/*********************************/
.data
szMessResult:  .asciz "Counter =  @ \n"      // message result

/*********************************/
/* UnInitialized data            */
/*********************************/
.bss 
sZoneConv:              .skip 24
/*********************************/
/*  code section                 */
/*********************************/
.text
.global main 
main:                          // entry of program 
    mov x4,#10
1:                             // begin loop 
    mov x0,x4
    ldr x1,qAdrsZoneConv       // display value
    bl conversion10            // call decimal conversion
    ldr x0,qAdrszMessResult
    ldr x1,qAdrsZoneConv       // display value
    bl strInsertAtCharInc      // insert result at @ character
    bl affichageMess           // display message
    subs x4,x4,1               // decrement counter
    bge 1b                     // loop if greather
 
100:                           // standard end of the program 
    mov x0,0                   // return code
    mov x8,EXIT                // request to exit program
    svc 0                      // perform the system call
 
qAdrsZoneConv:            .quad sZoneConv
qAdrszMessResult:         .quad szMessResult
/********************************************************/
/*        File Include fonctions                        */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"

Ada

for I in reverse 0..10 loop
   Put_Line(Integer'Image(I));
end loop;

Agena

Tested with Agena 2.9.5 Win32

for i from 10 downto 0 do
    print( i )
od

ALGOL 60

Works with: A60

Based on the 1962 Revised Report on ALGOL:

 begin
   integer i;
   for i:=10 step -1 until 0 do 
     outinteger(1,i)
 end

Works with: ALGOL 60 version OS/360

'BEGIN' 'COMMENT' Loops/Downward for - Algol60 - 23/06/2018;
  'INTEGER' I;
  'FOR' I := 10 'STEP' -1 'UNTIL' 0 'DO' 
    OUTINTEGER(1,I)
'END'

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

FOR i FROM 10 BY -1 TO 0 DO
    print((i,new line))
OD

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.

FOR i FROM 10 DOWNTO 0 DO
    print((i,new line))
OD

ALGOL-M

Sadly, ALGOL-M's FOR statement does not allow a negative value for STEP, so in order to count down we either have to use a WHILE loop or move the subtraction into the body of the FOR loop

begin

integer i;

write("First approach :");
i := 10;
while (i >= 0) do
   begin  
      writeon(i);
      i := i - 1;
   end;

write("Second approach:");
for i := 0 step 1 until 10 do
  writeon(10-i);

end

Output:

First approach :     10      9      8      7      6      5      4      3      2      1      0
Second approach:     10      9      8      7      6      5      4      3      2      1      0

ALGOL W

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

Amazing Hopper

#include <flow.h>

DEF-MAIN
   CLR-SCR
   SET(i, 10)
   LOOP(ciclo abajo)
      PRNL(i)
   BACK-IF-NOT-ZERO(i--, ciclo abajo)
END

Output:

AmigaE

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

AppleScript

repeat with i from 10 to 0 by -1
  log i
end repeat

ARM Assembly

Works with: as version Raspberry Pi

/* ARM assembly Raspberry PI  */
/*  program loopdownward.s   */

/* Constantes    */
.equ STDOUT, 1     @ Linux output console
.equ EXIT,   1     @ Linux syscall
.equ WRITE,  4     @ Linux syscall

/*********************************/
/* Initialized data              */
/*********************************/
.data
szMessResult:  .ascii "Counter = "      @ message result
sMessValeur:   .fill 12, 1, ' '
                   .asciz "\n"
/*********************************/
/* UnInitialized data            */
/*********************************/
.bss 
/*********************************/
/*  code section                 */
/*********************************/
.text
.global main 
main:                @ entry of program 
    push {fp,lr}      @ saves 2 registers 
    mov r4,#10
1:    @ begin loop 
    mov r0,r4
    ldr r1,iAdrsMessValeur     @ display value
    bl conversion10             @ call function with 2 parameter (r0,r1)
    ldr r0,iAdrszMessResult
    bl affichageMess            @ display message
    subs r4,#1                   @ decrement counter
    bge 1b                      @ loop if greather

100:   @ standard end of the program 
    mov r0, #0                  @ return code
    pop {fp,lr}                 @restaur 2 registers
    mov r7, #EXIT              @ request to exit program
    svc #0                       @ perform the system call

iAdrsMessValeur:          .int sMessValeur
iAdrszMessResult:         .int szMessResult
/******************************************************************/
/*     display text with size calculation                         */ 
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
    push {r0,r1,r2,r7,lr}      @ save  registres
    mov r2,#0                  @ counter length 
1:      @ loop length calculation 
    ldrb r1,[r0,r2]           @ read octet start position + index 
    cmp r1,#0                  @ if 0 its over 
    addne r2,r2,#1            @ else add 1 in the length 
    bne 1b                    @ and loop 
                                @ so here r2 contains the length of the message 
    mov r1,r0        			@ address message in r1 
    mov r0,#STDOUT      		@ code to write to the standard output Linux 
    mov r7, #WRITE             @ code call system "write" 
    svc #0                      @ call systeme 
    pop {r0,r1,r2,r7,lr}        @ restaur des  2 registres */ 
    bx lr                       @ return  
/******************************************************************/
/*     Converting a register to a decimal                                 */ 
/******************************************************************/
/* r0 contains value and r1 address area   */
conversion10:
    push {r1-r4,lr}    @ save registers 
    mov r3,r1
    mov r2,#10

1:	   @ start loop
    bl divisionpar10 @ r0 <- dividende. quotient ->r0 reste -> r1
    add r1,#48        @ digit	
    strb r1,[r3,r2]  @ store digit on area
    sub r2,#1         @ previous position
    cmp r0,#0         @ stop if quotient = 0 */
    bne 1b	          @ else loop
    @ and move spaces in first on area
    mov r1,#' '   @ space	
2:	
    strb r1,[r3,r2]  @ store space in area
    subs r2,#1       @ @ previous position
    bge 2b           @ loop if r2 >= zéro 

100:	
    pop {r1-r4,lr}    @ restaur registres 
    bx lr	          @return
/***************************************************/
/*   division par 10   signé                       */
/* Thanks to http://thinkingeek.com/arm-assembler-raspberry-pi/*  
/* and   http://www.hackersdelight.org/            */
/***************************************************/
/* r0 dividende   */
/* r0 quotient */	
/* r1 remainder  */
divisionpar10:	
  /* r0 contains the argument to be divided by 10 */
    push {r2-r4}   /* save registers  */
    mov r4,r0 
    mov r3,#0x6667   @ r3 <- magic_number  lower
    movt r3,#0x6666  @ r3 <- magic_number  upper
    smull r1, r2, r3, r0   @ r1 <- Lower32Bits(r1*r0). r2 <- Upper32Bits(r1*r0) 
    mov r2, r2, ASR #2     /* r2 <- r2 >> 2 */
    mov r1, r0, LSR #31    /* r1 <- r0 >> 31 */
    add r0, r2, r1         /* r0 <- r2 + r1 */
    add r2,r0,r0, lsl #2   /* r2 <- r0 * 5 */
    sub r1,r4,r2, lsl #1   /* r1 <- r4 - (r2 * 2)  = r4 - (r0 * 10) */
    pop {r2-r4}
    bx lr                  /* leave function */

Arturo

loop 10..0 'i [
	print i
]

Output:

Asymptote

Asymptote's control structures are similar to those in C, C++, or Java

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

AutoHotkey

x := 10
While (x >= 0)
{
  output .= "`n" . x
  x--
}
MsgBox % output

Avail

For each i from 10 to 0 by -1 do [Print: “i” ++ "\n";];

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

AWK

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

Axe

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

For(I,0,10)
 Disp 10-I▶Dec,i
End

Bait

fun main() {
	for i := 10; i >= 0; i -= 1 {
		println(i)
	}
}

BASIC

Applesoft BASIC

FOR I = 10 TO 0 STEP -1 : PRINT I : NEXT I

BaCon

' Downward for
FOR i = 10 DOWNTO 0 : PRINT i : NEXT

BASIC256

Works with: QBasic

for i = 10 to 0 step -1
	print i; " ";
next i
print
end

BBC BASIC

      FOR i% = 10 TO 0 STEP -1
        PRINT i%
      NEXT

Commodore BASIC

10 FOR I = 10 TO 0 STEP -1
20 PRINT I 
30 NEXT

Chipmunk Basic

The GW-BASIC solution works without any changes.

FBSL

#APPTYPE CONSOLE

FOR DIM i = 10 DOWNTO 0
    PRINT i
NEXT

PAUSE

FreeBASIC

' FB 1.05.0 Win64

For i As Integer = 10 To 0 Step -1
  Print i; " ";
Next
Print 
Sleep

Output:

 10  9  8  7  6  5  4  3  2  1  0

Gambas

Click this link to run this code

Public Sub Main()
Dim siCount As Short

For siCount = 10 DownTo 0
  Print siCount;;
Next

End

Output:

10 9 8 7 6 5 4 3 2 1 0

GW-BASIC

Works with: BASICA

Works with: PC-BASIC version any

10 FOR I% = 10 TO 0 STEP -1
20  PRINT I%
30 NEXT I%

IS-BASIC

100 FOR I=10 TO 0 STEP-1
110   PRINT I
120 NEXT

Liberty BASIC

Works with: Just BASIC

Works with: Run BASIC

for i = 10 to 0 step -1
   print i
next i
end

Microsoft Small Basic

For i = 10 To 0 Step -1
  TextWindow.WriteLine(i)
EndFor

MSX Basic

The GW-BASIC solution works without any changes.

NS-HUBASIC

10 FOR 1=10 TO 0 STEP -1
20 PRINT I
30 NEXT

PureBasic

For i=10 To 0 Step -1
  Debug i
Next

QB64

CBTJD: 2020/03/14

FOR n = 10 TO 0 STEP -1
    PRINT n
NEXT

QuickBASIC

for i = 10 to 0 step -1
   print i
next i

Quite BASIC

The GW-BASIC solution works without any changes.

Run BASIC

Works with: Just BASIC

Works with: Liberty BASIC

for i = 10 to 0 step -1
   print i
next i
end

SmallBASIC

for ii = 10 to 0 step -1
  print ii
next

TI-83 BASIC

:For(I,10,0,-1
:Disp I
:End

TI-89 BASIC

Local i
For i, 10, 0, –1
  Disp i
EndFor

True BASIC

Works with: QBasic

FOR i = 10 TO 0 STEP -1
    PRINT i; " ";
NEXT i
PRINT
END

Tiny BASIC

Works with: TinyBasic

10 REM Loops/Downward for
20 LET I = 10
30 IF I = -1 THEN END
40 PRINT I
50 LET I = I - 1
60 GOTO 30
70 END

VBA

For i = 10 To 0 Step -1
   Debug.Print i
Next i

Visual Basic .NET

For i = 10 To 0 Step -1
    Console.WriteLine(i)
Next

XBasic

Works with: Windows XBasic

PROGRAM "downwardfor"

DECLARE FUNCTION Entry()

FUNCTION Entry()
  FOR i% = 10 TO 0 STEP -1
    PRINT i%
  NEXT i%
END FUNCTION
END PROGRAM

Yabasic

Works with: QBasic

for i = 10 to 0 step -1
    print i, " ";
next i
print
end

ZX Spectrum Basic

10 FOR l = 10 TO 0 STEP -1
20 PRINT l
30 NEXT l

Batch File

@echo off
for /l %%D in (10,-1,0) do echo %%D

bc

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

Befunge

55+>:.:v
@  ^ -1_

BQN

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

•Show¨⌽↕11

Bracmat

  10:?i
& whl'(out$!i&!i+-1:~<0:?i)

Brainf***

>++++++++[-<++++++>]    //cell 0 now contains 48 the ASCII code for "0"
<+.-.                   //print the digits 1 and 0
>++++++++++.            //cell 1 now contains the carriage return; print it!
>+++++++++              //cell 2 now contains the number 9; this is our counter
<<+++++++++>>           //cell 0 now contains 57 the ASCII code for "9"
[<<.->.>-]              //print and decrement the display digit; print a newline; decrement the loop variable
<<.>.                   //print the final 0 and a final newline

Brat

10.to 0 { n | p n }

C

int i;
for(i = 10; i >= 0; --i)
  printf("%d\n",i);

C#

for (int i = 10; i >= 0; i--)
{
   Console.WriteLine(i);
}

C++

for(int i = 10; i >= 0; --i)
  std::cout << i << "\n";

C3

for (int i = 10; i >= 0; i--)
{
  io::printn(i);
}

Ceylon

for (i in 10..0) {
    print(i);
}

Chapel

for i in 1..10 by -1 do
	writeln(i);

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

var r = 1..10;
for i in r by -1 do { ... }

Clipper

   FOR i := 10 TO 0 STEP -1
      ? i
   NEXT

Clojure

(doseq [x (range 10 -1 -1)] (println x))

COBOL

free-form

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.

Output:

CoffeeScript

This could be written either in the array comprehension style, or in "regular" for loop style.

# 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

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

ColdFusion

With tags:

<cfloop index = "i" from = "10" to = "0" step = "-1">
  #i#
</cfloop>

With script:

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

Common Lisp

(loop for i from 10 downto 1 do
  (print i))

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
   dec                           ; Create tag dec
    (print count)                ; Prints count
    (decf count)                 ; Decreases count
    (if (not (< count 0))        ; Ends loop when negative
        (go dec))))              ; Loops back to tag dec

Using Recursion

(defun down-to-0 (count)
  (print count)
  (if (not (zerop count))
      (down-to-0 (1- count))))
(down-to-0 10)

Output:

Computer/zero Assembly

LDA 28
SUB 29
STA 31
STA 28
BRZ 6 ;branch on zero to STP
JMP 0
STP
...
org 28
byte 11
byte 1
byte 0

Output:

Emulator with program loaded

Crystal

10.step(to: 0, by: -1).each { |i|
    puts i
}

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);
}

Output:

Dart

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

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.

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

Using it

|dc < ./for.dc
10
9
...
0

Delphi

See Pascal

Draco

proc nonrec main() void:
    byte i;
    for i from 10 downto 0 do
        write(i," ")
    od
corp

Output:

10 9 8 7 6 5 4 3 2 1 0

DuckDB

Works with: DuckDB version V1.0

Using range()

from range(10, -1, -1) t(countdown);

Using a CTE

# Start at `start`
create or replace function task(start) as table (
   with recursive cte as (
     select start as n
     union all
     select 
        n - 1 as n
     from cte
     where n > 0
  ) 
  from cte
);

from task(10);

DWScript

for i := 10 downto 0 do
  PrintLn(i);

E

for i in (0..10).descending() { println(i) }

EasyLang

for i = 10 downto 0
  print i
.

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

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.

[ Loop with downward counter
  ==========================

  A program for the EDSAC

  Prints the integers 10 down to 0

  The counter is stored at address 20@

  Its initial value is 9 * 2^12
  (9 in the high 5 bits, representing
  the character '9') and it counts
  down in steps of 2^12

  Works with Initial Orders 2 ]

        T56K    [ set load point ]
        GK      [ set base address ]

[ orders ]

        O14@    [ print figure shift ]
        O15@    [ print '1' ]
        O16@    [ print '0' ]
        O17@    [ print CR ]
        O18@    [ print LF ]

[ 5 ]   O20@    [ print c ]
        O17@    [ print CR ]
        O18@    [ print LF ]

        T19@    [ acc := 0 ]
        A20@    [ acc += c ]
        S15@    [ acc -:= character '1' ]
        U20@    [ c := acc ]

        E5@     [ branch on non-negative ]

        ZF      [ stop ]

[ constants ]

[ 14 ]  #F      [ πF -- figure shift ]
[ 15 ]  QF      [ character '1' ]
[ 16 ]  PF      [ character '0' ]
[ 17 ]  @F      [ θF -- CR ]
[ 18 ]  &F      [ ΔF -- LF ]

[ variables ]

[ 19 ]  P0F     [ used to clear acc ]
[ 20 ]  OF      [ character c = '9' ]

        EZPF    [ start when loaded ]

EGL

for ( i int from 10 to 0 decrement by 1 )
   SysLib.writeStdout( i );
end

Ela

Standard Approach

open monad io

each [] = do return ()
each (x::xs) = do
  putStrLn $ show x
  each xs

each [10,9..0] ::: IO

Alternative Approach

open monad io

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

_ = countDown 0 10 ::: IO

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

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.

Output:

ERRE

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

Euphoria

for i = 10 to 0 by -1 do
    ? i
end for

F#

Using an enumerable expression:

for i in 10..-1..0 do
  printfn "%d" i

Using the 'downto' keyword:

for i = 10 downto 0 do
  printfn "%d" i

Factor

11 <iota> <reversed> [ . ] each

FALSE

10[$0>][$." "1-]#.

Fantom

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

Fermat

for i = 10 to 0 by -1 do !!i; od

Forth

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

: loop-down  0 10 do  i .  -1 +loop ;

Fortran

Works with: Fortran version 90 and later

DO i = 10, 0, -1
  WRITE(*, *) i
END DO

Works with: Fortran version 77 and later

      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

Frink

for i = 10 to 0 step -1
   println[i]

FutureBasic

window 1, @"Countdown", ( 0, 0, 400, 300 )

NSInteger i

for i = 10 to 0 step -1
print i
next

HandleEvents

Output:

GAP

for i in [10, 9 .. 0] do
    Print(i, "\n");
od;

GML

for(i = 10; i >= 0; i -= 1)
    show_message(string(i))

Go

for i := 10; i >= 0; i-- {
  fmt.Println(i)
}

package main

import "fmt"
import "time"

func main() {
	i := 10
	for i > 0 {
		fmt.Println(i)
		time.Sleep(time.Second)
		i = i - 1
	}
	fmt.Println("blast off")
}

Groovy

for (i in (10..0)) {
    println i
}

Harbour

FOR i := 10 TO 0 STEP -1
   ? i
NEXT

Haskell

import Control.Monad

main :: IO ()
main = forM_ [10,9 .. 0] print

Haxe

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

class Step {
  var end:Int;
  var step:Int;
  var index:Int;

  public inline function new(start:Int, end:Int, step:Int) {
    this.index = start;
    this.end = end;
    this.step = step;
  }

  public inline function hasNext() return step > 0 ? end >= index : index >= end;
  public inline function next() return (index += step) - step;
}

class Main {
  static function main() {
    for (i in new Step(10, 0, -1)) {
      Sys.print('$i ');
    }
  }
}

Output:

10 9 8 7 6 5 4 3 2 1 0

hexiscript

for let i 10; i >= 0; i--
  println i
endfor

HicEst

DO i = 10, 0, -1
  WRITE() i
ENDDO

HolyC

I8 i;
for (i = 10; i >= 0; --i)
  Print("%d\n", i);

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

every i := 10 to 0 by -1 do {
   # things to do within the loop
   }

IDL

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

for i=10,0,-1 do print,i

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:

print,10-indgen(11)

Inform 6

for(i = 10: i >= 0: i--)
    print i, "^";

Io

for(i,10,0,-1,
    i println
)

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

3 : 0 ] 11
  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:

thru=: <. + i.@(+*)@-~

For example:

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

(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. (However, note that this particular implementation of 'thru' will return an empty result if the starting and ending values are the same. Whether that's useful or a problem, depends on the application.)

Java

for (int i = 10; i >= 0; i--) {
    System.out.println(i);
}

JavaScript

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

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:

for (var i = 11; i--;) console.log(i);

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.

var i = 11;
while (i--) console.log(i);

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:

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);
  }
);

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()

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

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

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

jq

If range/3 is available in your jq:

range(10;-1;-1)

Otherwise:

range(-10;1) | -.

Julia

for i in 10:-1:0
    println(i)
end

Kotlin

// version 1.3.61

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

Lambdatalk

{def downward_for
 {lambda {:i}
   {if {< :i 0}
    then (end of loop)
    else :i {downward_for {- :i 1}}}}}
-> downward_for

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

langur

for i in 10..0 {
    writeln i
}

for i = 10; i > -1; i -= 1 {
    writeln i
}

Lasso

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

LDPL

data:
i is number

procedure:
for i from 10 to -1 step -1 do
    display i lf
repeat

Lhogho

Slightly different syntax for for compared to Logo.

for "i [10 0] [print :i]

Lingo

repeat with i = 10 down to 0
  put i
end repeat

Lisaac

10.downto 0 do { i : INTEGER;
  i.println;
  
};

LiveCode

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

local x=10
repeat for 10 times                                                                                                   
  put x & return                                                                                                        
  add -1 to x                                                                                                           
end repeat

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

repeat with n=10 down to 1
  put n
end repeat

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.

for [i 10 0] [print :i]

Lua

for i=10,0,-1 do
  print(i)
end

M2000 Interpreter

M2000 can operate a For like in BASIC or Like M2000. In M2000 mode, a For always execute at least one time the block inside. This FOR use absolute value of step, except when we have start value and end value the same value, so from sign of step, interpreter calculate the exit value.

We can change the iterator variable of a For, but this variable is a copy of actual iterator, and next step get the proper value. So we can't change the numbers of steps, but we can use continue to skip rest of code and execute next step, or exit to exit block and stop loop. Also we can use Goto to stop loop and continue from a label.

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.

This is not an error (each for has private counter value):

for i=1 to 10 :for i=1 to 2:Print i:Next i:Next i

We get 10 times two values: 1 2

Form 80, 50
Module Checkit {
      set switches "+For"
      For i=10 to 1 step -1 {
            Print i
      }
      Print i=0
      \\ this For switch make it like For in BASIC
      \\ block skipped
      For i=1 to 10 step -1 {
            Print i
      }
      print i=1
      \\ but this is the default behavior
      \\
      set switches "-For"
      \\ sign of step used when start is same as end to calculate the exit value of i
      \\ This is the standard, and a For always execute at least one time the block.
      \\ use absulute step_Value. Because 10>1 direction is downward.
      For i=10 to 1 step -1 {
            Print i
      }
      Print i=0
      \\  loop from 1 to 10, using abs(step_value)
      For i=1 to 10 step -1 {
            Print i
      }
      print i=11
      For i=1 to 1 step -1 {
            Print i
      }
      Print i=0
}
CheckIt

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
')

Maple

Using an explicit loop:

for i from 10 to 0 by -1 do print(i) end:

Pushing the loop into the kernel:

seq(print(i),i=10..0,-1)

Mathematica /Wolfram Language

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:

For[i = 10, i >= 0, i--, Print[i]]

Using Do:

Do[Print[i], {i, 10, 0, -1}]

Using Scan:

Scan[Print, Range[10, 0, -1]]

MATLAB / Octave

    for k = 10:-1:0,
        printf('%d\n',k)
    end;

A vectorized version of the code is

  printf('%d\n',10:-1:0);

Maxima

for i from 10 thru 0 step -1 do print(i);

MAXScript

for i in 10 to 0 by -1 do print i

Mercury

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

Metafont

for i = 10 step -1 until 0: show i; endfor
end

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

for i = 10 downto 0: show i; endfor end

min

Works with: min version 0.19.6

10 :n (n 0 >=) (n puts! n pred @n) while

Or

10 (dup 0 <) 'pop (puts pred) () linrec

MiniScript

for i in range(10, 0)
    print i
end for

МК-61/52

1	0	П0	ИП0	L0	03	С/П

Modula-2

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.

Modula-3

FOR i := 10 TO 0 BY -1 DO
  IO.PutInt(i);
END;

MUMPS

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

N/t/roff

.nr a 11 1
.while (\na > 0) \{\
\n-a
.\}

Output:

10 9 8 7 6 5 4 3 2 1 0

Nemerle

for (i = 10; i >= 0; i--) {WriteLine($"$i")}

foreach (i in [10, 9 .. 0]) {WriteLine($"$i")}

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_

NewLISP

(for (i 10 0)
  (println i))

Nim

for x in countdown(10,0): echo(x)

Output:

Nu

for i in 10..0 {print $i}

Oberon-2

FOR i := 10 TO 0 BY -1 DO
  Out.Int(i,0);
END;

Objeck

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

OCaml

for i = 10 downto 0 do
  Printf.printf "%d\n" i
done

Octave

for i = 10:-1:0
  % ...
endfor

Oforth

10 0 -1 step: i [ i println ]

Oz

for I in 10..0;~1 do
   {Show I}
end

PARI/GP

forstep(n=10,0,-1,print(n))

Pascal

for i := 10 downto 0 do
  writeln(i);

PascalABC.NET

##
for var i:=10 downto 0 do
  Print(i);

Output:

10 9 8 7 6 5 4 3 2 1 0

Peloton

English fixed-length opcodes

<@ ITEFORLITLITLITLIT>0|<@ SAYVALFOR>...</@>|10|-1</@>

Simplified Chinese variable-length opcodes

<# 迭代迭代次数字串字串字串字串>0|<# 显示值迭代次数>...</#>|10|-1</#>

Perl

foreach (reverse 0..10) {
  print "$_\n";
}

Phix

Library: Phix/basics

for i=10 to 0 by -1 do
    ?i
end for

Phixmonti

/# Rosetta Code problem: https://rosettacode.org/wiki/Loops/Downward_for
by Galileo, 11/2022 #/

include ..\Utilitys.pmt

( 10 0 -1 ) for ? endfor

PHP

for ($i = 10; $i >= 0; $i--)
  echo "$i\n";

or

foreach (range(10, 0) as $i)
  echo "$i\n";

PicoLisp

(for (I 10 (ge0 I) (dec I))
   (println I) )

or:

(mapc println (range 10 0))

Pike

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

PL/0

var i;
begin
  i := 10;
  while i > -1 do
  begin
    ! i;
    i := i - 1
  end
end.

PL/I

do i = 10 to 0 by -1;
   put skip list (i);
end;

Plain English

One way might be:

To run:
Start up.
Put 11 into a counter.
Loop.
If the counter is below 0, break.
Convert the counter to a string.
Write the string on the console.
Repeat.
Wait for the escape key.
Shut down.

To decide if a counter is below a number:
Subtract 1 from the counter.
If the counter is less than the number, say yes.
Say no.

Pop11

lvars i;
for i from 10 by -1 to 0 do
   printf(i, '%p\n');
endfor;

PowerShell

for ($i = 10; $i -ge 0; $i--) {
    $i
}

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

10..0

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,Hi) :- Hi >= Lo.
rfor(Hi,Lo,Val) :- Hi > Lo, H is Hi - 1, !, rfor(H,Lo,Val).

reverse_iter :-
  rfor(10,0,Val), write(Val), nl, fail.
reverse_iter.

?- reverse_iter.
10
9
8
7
6
5
4
3
2
1
0
true.

Python

for i in xrange(10, -1, -1):
    print i

List comprehension

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

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

Quackery

11 times [ i echo sp ]

Output:

10 9 8 7 6 5 4 3 2 1 0

R

for(i in 10:0) {print(i)}

Racket

#lang racket

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

Raku

(formerly Perl 6)

Works with: Rakudo Star version 2010.08

for 10 ... 0 {
    .say;
}

REBOL

for i 10 0 -1 [print i]

Retro

11 [ putn space ] iterd

REXX

version 1

(equivalent to version 2 and version 3)

  do j=10  to 0  by -1
  say j
  end

version 2

(equivalent to version 1 and version 3)

  do j=10  by -1  to 0
  say j
  end

version 3

(equivalent to version 1 and version 2)

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

Hurrumph! Hurrumph!

  do j=10  by -2  to 0
  say j
  j=j+1     /*this increments the  DO  index.   Do NOT program like this! */
  end

version 4

This example isn't compliant to the task, but it shows that the increment/decrement can be a non-integer:

  do j=30  to 1  by -.25
  say j
  end

Ring

count from 10 to 0 by -1 step:

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

RPL

≪ 10 1 FOR n 
      n 
   -1 STEP
≫

Ruby

10.downto(0) do |i|
   puts i
end

Rust

fn main() {
    for i in (0..=10).rev() {
        println!("{}", i);
    }
}

Salmon

for (x; 10; x >= 0; -1)
    x!;

Sather

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

S-BASIC

var i = integer
for i = 10 to 1 step -1
  print i;
next i

end

Output:

 10 9 8 7 6 5 4 3 2 1

Scala

for(i <- 10 to 0 by -1) println(i)
//or
10 to 0 by -1 foreach println

Scheme

(do ((i 10 (- i 1)))
    ((< i 0))
    (display i)
    (newline))

Scilab

Works with: Scilab version 5.5.1

for i=10:-1:0
    printf("%d\n",i)
end

Output:

Seed7

for i range 10 downto 0 do
  writeln(i);
end for;

Sidef

for(;;) loop:

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

for-in loop:

for i in (11 ^.. 0) {
    say i
}

.each method:

10.downto(0).each { |i|
    say i
}

Simula

BEGIN
    Integer i;
    for i := 10 step -1 until 0 do
    BEGIN
        OutInt(i, 2);
        OutImage
    END
END

Slate

10 downTo: 0 do: [| :n | print: n]

Smalltalk

10 to: 0 by: -1 do:[:aNumber | 
  aNumber displayNl.
].

10 downTo: 0 do:[:eachNumber | 
  eachNumber displayNl.
]

Both enumerate 10 to 0 inclusive.

Non-Smalltalkers might be confused when seeing:

(10 to: 0 by: -1) do:[:eachNumber | 
  eachNumber displayNl.
]

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

The first one sends a "to:by:do:" message to the Integer 10, passing "0", "-1", and the closure as arguments. There (in the integer), the counting and closure invokation takes place (who cares how it does it?).

The second example first instantiates a range-collection object (called Interval in Smalltalk) with the "to:by:" message (sent to the integer), and then this Interval object gets a "do:" message.
Which - like all collections - enumerates its elements, in this case [10..0].

Thus the first variant is one message send (aka virtual function call) to the number, whereas the second is two message sends and an object instantiation.

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

(10 to: 5 by: -1),(0 to: 4) do:[:eachNumber | 
  eachNumber displayNl.
]

to enumerate in a different order,
or combine ranges with a constant array:

(10 to: 0 by: -2),#(99 999),(1 to: 9 by: 2) do:[:each | 
  each displayNl.
]

or with a computed array:

(10 to: 0 by: -2),{ 10 factorial . 11 factorial},(1 to: 9 by: 2) do:[:each | 
  each displayNl.
]

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

(0 to:10) reverseDo:[:each | 
  each displayNl.
]

SNOBOL4

        COUNT = 10
LOOP    OUTPUT = COUNT
        COUNT = COUNT - 1
        GE(COUNT, 0)     :S(LOOP)
END

SNUSP

++++++++++>++++++++++!/- @!\=@\.@@@-@-----#   atoi
    \n      counter  #\?>.</  \ @@@+@+++++#   itoa
                       loop

Sparkling

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

Spin

Works with: BST/BSTC

Works with: FastSpin/FlexSpin

Works with: HomeSpun

Works with: OpenSpin

con
  _clkmode = xtal1 + pll16x
  _clkfreq = 80_000_000

obj
  ser : "FullDuplexSerial.spin"

pub main | n
  ser.start(31, 30, 0, 115200)

  repeat n from 10 to 0
    ser.dec(n)
    ser.tx(32)

  waitcnt(_clkfreq + cnt)
  ser.stop
  cogstop(0)

Output:

10 9 8 7 6 5 4 3 2 1 0

SPL

> i, 10..0,-1
  #.output(i)
<

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 n (stored at address 18) from the illegal instruction c to 32, yielding the actual instruction we use to store n into the array.

10001000000000100000000000000000   0. -17 to c
11001000000001100000000000000000   1. c to 19
11001000000000100000000000000000   2. -19 to c
01001000000000010000000000000000   3. Sub. 18
00010000000001100000000000000000   4. c to 8
01001000000000100000000000000000   5. -18 to c
11001000000001100000000000000000   6. c to 19
11001000000000100000000000000000   7. -19 to c
00000000000000000000000000000000   8. generated at run time
11110000000000010000000000000000   9. Sub. 15
01001000000001100000000000000000  10. c to 18
11110000000000010000000000000000  11. Sub. 15
00000000000000110000000000000000  12. Test
00001000000000000000000000000000  13. 16 to CI
00000000000001110000000000000000  14. Stop
10000000000000000000000000000000  15. 1
11111111111111111111111111111111  16. -1
00000100000001100000000000000000  17. c to 32
01010000000000000000000000000000  18. 10

Stata

See forvalues and foreach in Stata help.

forvalues n=10(-1)0 {
        display `n'
}

forvalues n=10 9 to 0 {
        display `n'
}

foreach n of numlist 10/0 {
        display `n'
}

Swift

for i in stride(from: 10, through: 0, by: -1) {
  println(i)
}

Alternately:

for i in lazy(0...10).reverse() {
  println(i)
}

In Swift 1.2 Alternately:

for i in reverse(0 ... 10) {
  println(i)
}

Alternately (removed in Swift 3):

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

Swift 3:

for i in (0...10).reversed() {
    print(i)
}

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

TAV

The function 'from () downto ()' generates 10..0, then stops the loop. Scan functions like this are simplified coroutines.

  ?# i =: from 10 downto 0
    print i

Alternatively:

  ?# i =: from 20 downto 0 step 2
    print i // 2

Tcl

for {set i 10} {$i >= 0} {incr i -1} {
    puts $i
}
# puts "We have liftoff!"

Trith

10 inc iota reverse [print] each

10 [dup print dec] [dup 0 >=] while drop

TUSCRIPT

$$ MODE TUSCRIPT
LOOP n=10,0,-1
 PRINT n
ENDLOOP

UNIX Shell

Works with: Bourne Shell

i=10
while test $i -ge 0; do
	echo $i
	i=`expr $i - 1`
done

# or

jot - 10 0 -1

# or

seq 10 -1 0

Works with: bash

for(( Z=10; Z>=0; Z-- )); do
    echo $Z
done

#or

for Z in {10..0}; do
    echo $Z
done

UnixPipes

Works with: OpenBSD version 4.9

yes '' | cat -n | head -n 11 | while read n; do
	expr $n - 1
done | tail -r

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.

Ursa

decl int i
for (set i 10) (> i -1) (dec i)
	out i endl console
end for

V

10 
[0 >]
  [dup puts pred]
while

Vala

for (int i = 10; i >= 0; --i)
    stdout.printf("%d\n", i);

Vedit macro language

for (#1 = 10; #1 >= 0; #1--) {
    Num_Type(#1)
}

Verilog

module main;
  integer  i;
  
  initial begin

    for(i = 10; i >= 0; i = i - 1)  $write(i);
  $finish ;
  end
endmodule

V (Vlang)

fn main() {
    for i := 10; i >= 0; i-- {
        print('$i ')
    }
}

Output:

10 9 8 7 6 5 4 3 2 1 0

Wart

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

Wren

for (i in 10..0) System.write("%(i) ")
System.print()

Output:

10 9 8 7 6 5 4 3 2 1 0

XPL0

include c:\cxpl\codes;          \intrinsic 'code' declarations
int I;
for I:= 10 downto 0 do
        [IntOut(0, I); CrLf(0)]

Z80 Assembly

Because of the way looping typically works in hardware, as well as 10 being two digits, it's more efficient to only print numbers 9 through 1 in the loop body, and do the rest outside it.

org &1000

LD A,'1'
CALL &BB5A
LD A,'0'
CALL &BB5A

LD B,9
LD A,'9'

for:
CALL &BB5A
DEC A
DJNZ for

LD A,'0'
JP &BB5A	;its RET returns to BASIC for us.

Output:

Amstrad Microcomputer   (v4)
(c) 1985 Amstrad plc 
         and Locomotive Software Ltd.
ParaDOS V1.2+ (c)2015 BitWise Systems.

BASIC 1.1
Ready
call &1000
109876543210
Ready

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)

Zig

const std = @import("std");

pub fn main() !void {
    var i: u8 = 11;
    while (i > 0) {
        i -= 1;
        try std.io.getStdOut().writer().print("{d}\n", .{i});
    }
}