Loops/Downward for: Difference between revisions

*   [[Loops/Wrong ranges]]

<br><br>

=={{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|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}}==

'''begin'''

'''integer''' i;

'''for''' i:=10 '''step''' -1 '''until''' 0 '''do'''

'''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|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}}==

{{out}}

1

0</pre>

=={{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}}===

print 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}}

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

for i = 10 to 0 step -1

print i

next

Output:

9

8

2

1

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

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

Dim siCount As Short

Next

Output:

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

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

20 PRINT I%

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

110 PRINT I

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

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

print i

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

:Disp I

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

For i, 10, 0, –1

Disp i

==={{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|Bracmat}}==

=={{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}}

0

</pre>

=={{header|D}}==

void main() {

foreach_reverse (i ; 0 .. 10 + 1)

writeln(i);

{{out}}

<pre>10

0</pre>

does not use GNU extensions

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}}==

:''See [[#Pascal|Pascal]]''

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

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}}==