Loops/Downward for: Difference between revisions

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

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

Use of BXLE and BCT opcodes.

LOOPDOWN CSECT

USING LOOPDOWN,R12

BUFFER DC CL80' '

YREGS

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

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

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

;value contained in the Accumulator

Send = $9000 ;routine not implemented here

ORA #$30

JSR Send ;routine not implemented here

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

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

MOVE.W #10,D0

loop:

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

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

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

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

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

ret

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program loopdownward64.s */

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

.include "../includeARM64.inc"

=={{header|Ada}}==

Put_Line(Integer'Image(I));

=={{header|Agena}}==

Tested with Agena 2.9.5 Win32

print( i )

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

'''end'''

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

'INTEGER' I;

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

OUTINTEGER(1,I)

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

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

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

print((i,new line))

As a common extension the DOWNTO is sometimes included to optimise

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

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

print((i,new line))

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

for i := 10 step -1 until 0 do

begin

write( i )

end

=={{header|Amazing Hopper}}==

#include <flow.h>

BACK-IF-NOT-ZERO(i--, ciclo abajo)

END

{{out}}

<pre>

</pre>

=={{header|AmigaE}}==

DEF i

FOR i := 10 TO 0 STEP -1

WriteF('\d\n', i)

ENDFOR

=={{header|AppleScript}}==

log i

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

=={{header|Arturo}}==

print i

{{out}}

=={{header|Asymptote}}==

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

write(i);

=={{header|AutoHotkey}}==

While (x >= 0)

{

}

MsgBox % output

=={{header|Avail}}==

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

=={{header|AWK}}==

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

print i

}

=={{header|Axe}}==

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

Disp 10-I▶Dec,i

=={{header|BASIC}}==

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

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

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

{{works with|QBasic}}

print i; " ";

next i

print

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

PRINT i%

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

20 PRINT I

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

For i As Integer = 10 To 0 Step -1

Next

Print

{{out}}

<pre>

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

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

HandleEvents

Output:

<pre>

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

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

Dim siCount As Short

Next

Output:

<pre>

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

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

10 FOR I% = 10 TO 0 STEP -1

20 PRINT I%

30 NEXT I%

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

110 PRINT I

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

{{works with|Just BASIC}}

{{works with|Run BASIC}}

for i = 10 to 0 step -1

print i

next i

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

For i = 10 To 0 Step -1

TextWindow.WriteLine(i)

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

20 PRINT I

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

Debug i

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

''CBTJD'': 2020/03/14

PRINT n

==={{header|QBASIC}}===

print i

==={{header|Run BASIC}}===

{{works with|Just BASIC}}

{{works with|Liberty BASIC}}

print i

next i

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

:For(I,10,0,-1

:Disp I

:End

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

For i, 10, 0, –1

Disp i

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

{{works with|QBasic}}

PRINT i; " ";

NEXT i

PRINT

==={{Header|Tiny BASIC}}===

10 IF i = -1 THEN END

PRINT i

LET i = i - 1

GOTO 10

==={{header|Yabasic}}===

{{works with|QBasic}}

print i, " ";

next i

print

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

{{works with|Windows XBasic}}

DECLARE FUNCTION Entry()

NEXT i%

END FUNCTION

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

20 PRINT l

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

=={{header|bc}}==

=={{header|Befunge}}==

=={{header|BQN}}==

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

=={{header|Bracmat}}==

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

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

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

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

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

=={{header|Brat}}==

=={{header|C}}==

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

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

{

Console.WriteLine(i);

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

=={{header|Ceylon}}==

print(i);

=={{header|Chapel}}==

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

=={{header|Clipper}}==

? i

=={{header|Clojure}}==

=={{header|COBOL}}==

free-form

program-id. countdown.

environment division.

display counter-disp

end-perform

{{out}}

<pre>10

This could be written either in the array comprehension style,

or in "regular" for loop style.

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

# More compact version of the above

<pre>10

9

=={{header|ColdFusion}}==

With tags:

#i#

With script:

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

{

writeOutput( i );

}

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

=== Using DO ===

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

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

(print n)) ; On every loop print value

=== Using Tagbody and Go ===

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

(tagbody

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

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

=== Using Recursion ===

(defun down-to-0 (count)

(print count)

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

(down-to-0 10)

{{out}}

=={{header|Computer/zero Assembly}}==

SUB 29

STA 31

byte 11

byte 1

{{out}}[http://www.edmundgriffiths.com/czero.html?hexdump=3c9d5f5ca6c0e00000000000000000000000000000000000000000000b01000a Emulator with program loaded]

=={{header|Crystal}}==

puts i

}

=={{header|D}}==

void main() {

foreach_reverse (i ; 0 .. 10 + 1)

writeln(i);

{{out}}

<pre>10

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

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

0 10 ldx [p] sf !<m

Using it

10

9

...

=={{header|Delphi}}==

=={{header|Draco}}==

byte i;

for i from 10 downto 0 do

write(i," ")

od

{{out}}

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

=={{header|DWScript}}==

=={{header|E}}==

=={{header|EasyLang}}==

print i

=={{header|EchoLisp}}==

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

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

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

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

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

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

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

=={{header|EGL}}==

SysLib.writeStdout( i );

=={{header|Ela}}==

===Standard Approach===

each [] = do return ()

each xs

===Alternative Approach===

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

countDown m (n - 1)

=={{header|Elixir}}==

10

9

1

0

=={{header|Erlang}}==

-module(downward_loop).

-export([main/0]).

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

end.

{{out}}

<pre>10

=={{header|ERRE}}==

FOR I%=10 TO 0 STEP -1 DO

PRINT(I%)

END FOR

=={{header|Euphoria}}==

? i

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

Using an enumerable expression:

Using the 'downto' keyword:

=={{header|Factor}}==

=={{header|FALSE}}==

=={{header|Fantom}}==

class DownwardFor

{

}

}

=={{header|FBSL}}==

FOR DIM i = 10 DOWNTO 0

PAUSE

=={{header|Fermat}}==

=={{header|Forth}}==

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

=={{header|Fortran}}==

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

WRITE(*, *) i

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

C Initialize the loop parameters.

INTEGER I, START, FINISH, STEP

STOP

=={{header|Frink}}==

for i = 10 to 0 step -1

println[i]

=={{header|GAP}}==

Print(i, "\n");

=={{header|GML}}==

=={{header|Go}}==

fmt.Println(i)

import "fmt"

}

fmt.Println("blast off")

=={{header|Groovy}}==

println i

=={{header|Harbour}}==

? i

=={{header|Haskell}}==

main :: IO ()

=={{header|Haxe}}==

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

var end:Int;

var step:Int;

}

}

{{out}}

=={{header|hexiscript}}==

println i

=={{header|HicEst}}==

WRITE() i

=={{header|HolyC}}==

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

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

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

# things to do within the loop

}

=={{header|IDL}}==

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

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

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

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

=={{header|Io}}==

i println

=={{header|J}}==

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

for_i. i. - y do.

smoutput i

end.

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

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

For example:

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

=={{header|Java}}==

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

System.out.println(i);

}

=={{header|JavaScript}}==

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

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

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

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

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

function (x, i) {

console.log(x);

}

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

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

function (x) {

}

).join('\n')

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

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

=={{header|jq}}==

If range/3 is available in your jq:

Otherwise:

range(-10;1) | -.

=={{header|Julia}}==

println(i)

=={{header|Kotlin}}==

// version 1.3.61

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

}

=={{header|Lambdatalk}}==

{def downward_for

{lambda {:i}

{downward_for 10}

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

=={{header|langur}}==

You can use a for in loop to count downward. You cannot use a for of loop for this.

writeln .i

writeln .i

=={{header|Lasso}}==

=={{header|Lhogho}}==

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

=={{header|Lingo}}==

put i

=={{header|Lisaac}}==

i.println;

=={{header|LiveCode}}==

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

repeat for 10 times

put x & return

add -1 to x

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

put n

=={{header|Logo}}==

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

=={{header|Lua}}==

for i=10,0,-1 do

print(i)

end

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

There is a slower For, the For Next style:

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

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

Form 80, 50

Module Checkit {

}

CheckIt

=={{header|M4}}==

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

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

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

=={{header|Maple}}==

Using an explicit loop:

Pushing the loop into the kernel:

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

Using For:

Using Do:

Using Scan:

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

printf('%d\n',k)

A vectorized version of the code is

=={{header|Maxima}}==

=={{header|MAXScript}}==

=={{header|Mercury}}==

:- interface.

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

),

=={{header|Metafont}}==

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

=={{header|min}}==

{{works with|min|0.19.6}}

Or

=={{header|MiniScript}}==