Loops/For with a specified step: Difference between revisions

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

{{out}}

;Basic - Algol style

The opcode BXH uses 3 registers, one for index one for step and one for limit.

LOOPFORS CSECT

USING LOOPFORS,R12

XDEC DS CL12 temp for edit

YREGS

{{out}}

<pre>

;Basic - Fortran style

The opcode BXLE uses 3 registers, one for index one for step and one for limit.

LA R3,BUF idx=0

LA R5,5 from 5

LA R3,4(R3) idx=idx+4

BXLE R5,R6,LOOPJ next j

;Structured Macros

LA R3,BUF idx=0

LA R5,5 from 5

AR R5,R6 i=i+step

ENDDO , next i

;Structured Macros HLASM

LA R3,BUF idx=0

DO FROM=(R5,5),TO=(R7,25),BY=(R6,5) for i=5 to 25 step 5

LA R3,4(R3) idx=idx+4

ENDDO , next i

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

This loop loads from an array and writes each element to memory addresses $D000, $D002, $D004, $D006, $D008, $D00A, $D00C, $D00E, in ascending order.

define ArrayPointerHi $01

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

bpl loop_fill ;if destination index equals #$FF, we are done.

{{out}}

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program loopstep64.s */

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

.include "../includeARM64.inc"

=={{header|Action!}}==

BYTE i

PrintF("%B ",i)

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/For_with_a_specified_step.png Screenshot from Atari 8-bit computer]

Looper_3 most closely adheres to the requirements of this task, and achieves this by using a second range for the indices.

use Loopers;

end Loopers;

=={{header|Agena}}==

Tested with Agena 2.9.5 Win32

print( i )

=={{header|Aime}}==

i = 0;

}

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

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

for i := 3 step 2 until 9 do write( i )

=={{header|ALGOL-M}}==

INTEGER I;

FOR I := 1 STEP 3 UNTIL 19 DO

WRITE( I );

=={{header|AppleScript}}==

log i

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

=={{header|Arturo}}==

print i

{{out}}

<pre>0

=={{header|AutoHotkey}}==

iterations := 5

step := 10

MsgBox, % A_Index

}

=={{header|Avail}}==

Note the <code>0 to 100 by 7</code> segment 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.

=={{header|AWK}}==

for (i= 2; i <= 8; i = i + 2) {

print i

}

print "Ain't never too late!"

−

This example increments by 2:

Disp I▶Dec,i

I++

=={{header|BASIC}}==

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

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

This prints all odd digits:

FOR i = 1 TO 10 STEP 2

PRINT i

==={{header|Basic|QuickBasic}}===

{{works with|QuickBasic|4.5}}

print i; ", ";

next i

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

print i; " ";

next i

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

PRINT n

{{out}}

<pre>

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

20 PRINT I

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

For i As Integer = 1 To 21 Step 2

Next

Print

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

include "ConsoleWindow"

print s(i);

next

Output:

<pre>

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

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

Dim siCount As Short

Next

<pre>

Gambas is great!

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

110 PRINT I

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

for i = 2 to 8 step 2

print i; ", ";

print "who do we appreciate?"

end

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

For i = 0 To 100 Step 2

TextWindow.WriteLine(i)

EndFor

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

20 PRINT I

{{out}}

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

Debug i

{{out}}

<pre>

Decrementing with step

Debug i

{{out}}

<pre>

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

Print i%

Next 'To be more explicit use "Next i%"

{{out}}

A newline is inserted automatically after the Print statement

We can also decrement with stepping

Print i%

Next i

{{out}}

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

print i; ", ";

next i

{{out}}

<pre>2, 4, 6, 8, who do we appreciate?</pre>

Notice how the ampersand (&) is used to concatenate the variable with the text instead of a semicolon.

PRINT n & "..";

NEXT n

PRINT "who do we appreciate?"

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

Prints numbers from 0 to 100 stepping by 5.

:Disp I

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

For i, 0, 100, 5

Disp i

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

FOR i = 1 TO 21 STEP 2

PRINT i; " ";

NEXT i

END

{{out}}

<pre>

Since TrueBasic does not distinguish between integer or real values, we can increment using decimal values as well

FOR i = 1 TO 5 STEP .5

PRINT i

NEXT i

END

{{out}}

<pre>

==={{header|Visual Basic}}===

{{works with|Visual Basic|VB6 Standard}}

For i = 2 To 8 Step 2

Debug.Print i;

Next i

Debug.Print

{{out}}

<pre>

==={{header|Visual Basic .NET}}===

{{works with|Visual Basic .NET|.NET Core 3.0}}

Module Program

Sub Main()

WriteLine("who do we appreciate?")

End Sub

{{out}}

<pre>

{{works with|Visual Basic .NET|2011}}

Private Sub FormPG_Load(sender As Object, e As EventArgs) Handles MyBase.Load

Dim i As Integer, buffer As String

Debug.Print(buffer)

End Sub

{{out}}

<pre>

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

{{works with|Windows XBasic}}

PROGRAM "forby"

END FUNCTION

END PROGRAM

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

print i, " ";

next i

print

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

20 PRINT l; ", ";

30 NEXT l

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

for /l %%A in (1,2,10) do (

echo %%A

{{Out}}

<pre>>Sample.BAT

=={{header|bc}}==

i

=={{header|Befunge}}==

{{trans|C}}

=={{header|C}}==

This prints all odd digits:

for(i = 1; i < 10; i += 2)

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

class Program {

Console.WriteLine("who do we appreciate?");

}

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

This prints all odd digits:

=={{header|Ceylon}}==

for(i in (2..8).by(2)) {

}

print("who do we appreciate?");

=={{header|Chapel}}==

// Can be set on commandline via --N=x

config const N = 3;

writeln(i);

}

{{out}}

<pre>

=={{header|ChucK}}==

Chuck style

SinOsc s => dac;

100::ms => now;

}

General purpose style:

for (0 => int i; i < 2000; 5 +=> i )

{

<<< i >>>;

}

=={{header|Clojure}}==

The first example here is following the literal specification, but is not idiomatic Clojure code.

The second example achieves the same effect without explicit looping, and would (I think) be viewed as better code by the Clojure community.

(println i)

(when (< i 10)

(doseq [i (range 0 12 2)]

=={{header|CLU}}==

start_up = proc ()

stream$putl(po, int$unparse(i))

end

=={{header|COBOL}}==

PROGRAM-ID. Display-Odd-Nums.

GOBACK

=={{header|ColdFusion}}==

<cfloop from="0" to="99" step="3" index="i">

<Cfoutput>#i#</Cfoutput>

</cfloop>

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

(format t "~{~S, ~}who do we appreciate?~%" (loop for i from 2 to 8 by 2 collect i))

{{out}}

=== Using DO ===

(do ((n 0 (incf n (+ (random 3) 2)))) ; Initialize to 0 and set random step-value 2, 3 or 4

((> n 20)) ; Break condition

(print n)) ; On every loop print value

{{out}}

=={{header|D}}==

void main() {

foreach (i; iota(1, 10, 2))

writeln(i);

{{out}}

<pre>1

=={{header|Dao}}==

# max value: 9

# step: 2

=={{header|Delphi}}==

It would have to be simulated using something like a While loop.

{$APPTYPE CONSOLE}

Inc(i, 2);

end;

{{out}}

<pre>2

=={{header|Dragon}}==

show ", " + i

}

=={{header|DWScript}}==

for i := 2 to 8 step 2 do

{{out}}

=={{header|Dyalect}}==

for i in 1^2..10 {

print(i)

=={{header|E}}==

There is no step in the standard numeric range object (a..b and a..!b) in E, which is typically used for numeric iteration.

An ordinary while loop can of course be used:

while (i <= 8) {

print(`$i, `)

i += 2

}

A programmer frequently in need of iteration with an arbitrary step should define an appropriate range object:

def range {

to iterate(f) {

print(`$i, `)

}

The least efficient, but perhaps convenient, solution is to iterate over successive integers and discard undesired ones:

print(`$i, `)

}

=={{header|EchoLisp}}==

Steps may be integers, float, rationals.

(for ((i (in-range 0 15 2))) (write i))

0 2 4 6 8 10 12 14

(for ((x (in-range 0 15 PI))) (write x))

0 3.141592653589793 6.283185307179586 9.42477796076938 12.566370614359172

=={{header|Ela}}==

for m s n | n > m = do return ()

for m s (n+s)

{{out}}

=={{header|Elena}}==

ELENA 4.x

{

for(int i := 2, i <= 8, i += 2 )

console.writeLine:i

}

=={{header|Elixir}}==

def for_step(n, step) do

IO.inspect Enum.take_every(1..n, step)

end

{{out}}

</pre>

or

=={{header|Erlang}}==

%% for_loop/4 by Bengt Kleberg.

-module(loop_step).

for_loop( I+Step, End, Step, Do );

for_loop( _I, _End, _Step, _Do ) -> ok.

{{out}}

=={{header|ERRE}}==

FOR N=2 TO 8 STEP 1.5 DO

PRINT(N)

END FOR

{{out}}

<pre>

=={{header|Euphoria}}==

for i = 1 to 10 by 2 do

? i

end for

As a note, <code>? something</code> is shorthand for:

print(1, something)

puts(1, "\n")

<code>print()</code> differs from <code>puts()</code> in that <code>print()</code> will print out the actual <code>sequence</code> it is given.

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

printf "%d, " i

{{out}}

=={{header|Factor}}==

Prints odd digits.

=={{header|FALSE}}==

=={{header|Fantom}}==

class Main

{

}

}

=={{header|FBSL}}==

DIM n AS INTEGER

PRINT ", who will we obliterate?"

PAUSE

=={{header|Fermat}}==

{{out}}<pre>1 14 27 40 53 66 79 92</pre>

=={{header|FOCAL}}==

If a <tt>FOR</tt> statement has three parameters, they are (in order) the start, the step, and the end; if only two parameters are supplied, they are taken to be the start and the end. The step is then set to 1.

=={{header|Forth}}==

9 2 do

i .

2 +loop

=={{header|Fortran}}==

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

print *, i

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

INTEGER I

STOP

=={{header|Frink}}==

for a = 1 to 100 step 5

println[a]

All values may have units of measure, in which case a specified step is required:

for a = 1 km to 3 km step 1 meter

println[a]

=={{header|GAP}}==

# Use a range [a, b .. c], where the step is b-a (b is the value following a), and c-a must be a multiple of the step.

Print(i, "\n");

od;

9

11

=={{header|GML}}==

=={{header|Go}}==

This prints all odd digits:

fmt.Printf("%d\n", i)

=={{header|Groovy}}==

"for" loop:

print "${i} "

}

"each() method:

Though technically not a loop, most Groovy programmers would use the slightly more terse "each()" method on the collection itself, instead of a "for" loop.

print "${it} "

}

{{out}}

=={{header|Haskell}}==

main = do forM_ [2,4..8] (\x -> putStr (show x ++ ", "))

=={{header|Haxe}}==

While Haxe's for-loop does not allow you to directly specify the step size, it is easy to create an iterator that allows you to do that.

var end:Int;

var step:Int;

Sys.println('WHOM do we appreciate? GRAMMAR! GRAMMAR! GRAMMAR!');

}

{{out}}

=={{header|hexiscript}}==

println i

=={{header|HicEst}}==

WRITE() i

=={{header|HolyC}}==

This prints all odd digits:

for (i = 1; i < 10; i += 2)

=={{header|Hy}}==

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

Icon and Unicon accomplish loop stepping through the use of a generator, the ternary operator to-by, and the every clause which forces a generator to consume all of its results.

Because to-by is an operator it has precedence (just higher than assignments) and associativity (left) and can be combined with other operators.

every 1 to 10 by 2 # the simplest case that satisfies the task, step by 2

every writes( (TO_BY_EXPR) | "\n", " " ) # if you want to see how any of these work

The ability to combine to-by arbitrarily is quite powerful.

Yet it can lead to unexpected results. In cases of combined to-by operators the left associativity seems natural where the by is omitted.

=={{header|Io}}==

write(i,", ")

)

=={{header|J}}==

Or, using an actual for loop:

r=.$0

for_n. 2 * >: i.4 do.

' who do we appreciate?' ,~ ":n

)

That said, note also that J's '''steps''' verb lets us specify how many steps to take:

_8 _7 _6 _5 _4 _3 _2 _1 0 1 2 3 4 5 6 7 8

i:8j8

Or, if we prefer, we could borrow the definition of <code>thru</code> from the [[Loops/Downward_for#J|Downward for]] task and then filter for the desired values:

Example use:

2 4 6 8 10 12 14 16 18 20

(#~ 0 = 3&|) 1 thru 20

3 6 9 12 15 18

(#~ 1 = 3&|) 1 thru 20

And, of course, like filtering in any language, this approach supports non-constant step sizes:

=={{header|Java}}==

System.out.print(i + ", ");

}

=={{header|JavaScript}}==

i;

for (i = 2; i <= 8; i += 2) {

}

output += 'who do we appreciate?';

In a functional idiom of JavaScript, however, we will only be able to compose this computation within the superordinate expressions of our program if it has the the form of an expression returning a value, rather than that of a statement which fires off side-effects but returns no value.

Following the example of languages like Haskell and J on this page, we can begin by generating the stepped series as an expression. In functional JavaScript we will typically replace a state-changing loop with a non-mutating map or fold, writing, for example, something like:

// range(iMin, iMax)

// range(iMin, iMax, dI)

console.log(

range(2, 8, 2).join(', ') + ', who do we appreciate ?'

Output:

=={{header|jq}}==

def range(m;n;step): range(0; ((n-m)/step) ) | m + (. * step);

'''Example''':

(""; . + "\($i), ") +

=={{header|Julia}}==

print(i, ", ")

end

=={{header|Kotlin}}==

fun main(args: Array<String>) {

for (i in 1 .. 21 step 2) print("$i ")

{{out}}

=={{header|Lambdatalk}}==

{def loops_for_with_a_specified_step

{lambda {:a :b :step}

{S.map {lambda {:i} :i} {S.serie 0 9 2}}

-> 0 2 4 6 8

=={{header|Lang5}}==

: >>say.(*) . ;

=={{header|langur}}==

writeln .i

{{out}}

=={{header|Lasso}}==

loop_count

'\r' // for formatting

=={{header|LIL}}==

The '''inc''' command accepts a value to add to the variable, 1 if not specified.

{{out}}

<pre># for {set i 1} {$i < 15} {inc i 3} {print $i}

=={{header|Lingo}}==

Lingo loops don't support a "step" parameter, so it has to be implemented manually:

repeat with i = 0 to 10

put i

i = i + (step-1)

{{out}}

<pre>

=={{header|Lisaac}}==

i.print;

'\n'.print;

=={{header|LiveCode}}==

put n after loopn

if n is not 10 then put comma after loopn

end repeat

=={{header|Logo}}==

=={{header|Lua}}==

for i=2,9,2 do

print(i)

end

{{out}}

For this task we use single float numbers, and we make the loop one time from lower to higher value, and one time form higher to lower value.

Module LoopFor {

Locale 1036

}

LoopFor

{{Out}}

<pre>

</pre>

===Iterator step 2===

a=("A", "B", "C", "D", "E", "F", "Z")

k=Each(a)

}

Print