# Loops/For with a specified step

Loops/For with a specified step
You are encouraged to solve this task according to the task description, using any language you may know.

Demonstrate a for-loop where the step-value is greater than one.

## 360 Assembly

Basic - Algol style

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

`*        Loops/For with a specified step     12/08/2015LOOPFORS CSECT         USING  LOOPFORS,R12         LR     R12,R15*     == Algol style ================ test at the beginning         LA     R3,BUF             idx=0         LA     R5,0               from 5 (from-step=0)         LA     R6,5               step 5         LA     R7,25              to 25LOOPI    BXH    R5,R6,ELOOPI       for i=5 to 25 step 5         XDECO  R5,XDEC              edit i         MVC    0(4,R3),XDEC+8       output i         LA     R3,4(R3)             idx=idx+4         B      LOOPI              next iELOOPI   XPRNT  BUF,80             print buffer         BR     R14BUF      DC     CL80' '            bufferXDEC     DS     CL12               temp for edit         YREGS           END    LOOPFORS`
Output:
```   5  10  15  20  25
```
Basic - Fortran style

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

`*     == Fortran style ============== test at the end         LA     R3,BUF             idx=0         LA     R5,5               from 5         LA     R6,5               step 5         LA     R7,25              to 25LOOPJ    XDECO  R5,XDEC            for j=5 to 25 step 5;  edit j         MVC    0(4,R3),XDEC+8       output j         LA     R3,4(R3)             idx=idx+4         BXLE   R5,R6,LOOPJ        next j         XPRNT  BUF,80             print buffer`
Structured Macros
`*     == Algol style ================ test at the beginning         LA     R3,BUF             idx=0         LA     R5,5               from 5          LA     R6,5               step 5         LA     R7,25              to 25         DO WHILE=(CR,R5,LE,R7)    for i=5 to 25 step 5           XDECO  R5,XDEC            edit i            MVC    0(4,R3),XDEC+8     output i           LA     R3,4(R3)           idx=idx+4           AR     R5,R6              i=i+step         ENDDO  ,                  next i         XPRNT  BUF,80             print buffer`
Structured Macros HLASM
`*     == Fortran style ============== test at the end         LA     R3,BUF             idx=0         DO FROM=(R5,5),TO=(R7,25),BY=(R6,5)  for i=5 to 25 step 5           XDECO  R5,XDEC            edit i            MVC    0(4,R3),XDEC+8     output i           LA     R3,4(R3)           idx=idx+4         ENDDO  ,                  next i         XPRNT  BUF,80             print buffer`

The FOR loop construct in Ada does not give the programmer the ability to directly modify the loop control variable during the execution of the loop. Instead, a valid range must always be provided before entering a loop. Because exact adherence to the task is impossible, we have three versions to approximate a solution. Looper_1 goes through a range of values which are even. Looper_2 multiples each value by two. Looper_3 most closely adheres to the requirements of this task, and achieves this by using a second range for the indices.

`with Loopers;use Loopers;  procedure For_Main isbegin        Looper_1;        Looper_2;        Looper_3;end For_Main;  package Loopers is        procedure Looper_1;        procedure Looper_2;        procedure Looper_3;end Loopers; with Ada.Text_IO, Ada.Integer_Text_IO;use Ada.Text_IO, Ada.Integer_Text_IO; package body Loopers is        procedure Looper_1 is                Values : array(1..5) of Integer := (2,4,6,8,10);        begin                for I in Values'Range loop                        Put(Values(I),0);                        if I = Values'Last then                                Put_Line(".");                        else                                Put(",");                        end if;                end loop;        end Looper_1;         procedure Looper_2 is                E : Integer := 5;        begin                for I in 1..E loop                        Put(I*2,0);                        if I = E then                                Put_Line(".");                        else                                Put(",");                        end if;                end loop;        end Looper_2;         procedure Looper_3 is                Values : array(1..10) of Integer := (1,2,3,4,5,6,7,8,9,10);                Indices : array(1..5) of Integer := (2,4,6,8,10);        begin                for I in Indices'Range loop                        Put(Values(Indices(I)),0);                        if I = Indices'Last then                                Put_Line(".");                        else                                Put(",");                        end if;                end loop;        end Looper_3; end Loopers;  `

## Agena

Tested with Agena 2.9.5 Win32

`for i from 2 to 8 by 2 do    print( i )od`

## Aime

`integer i; i = 0;while (i < 10) {    o_winteger(2, i);    i += 2;} o_newline();`

## ALGOL 60

```for i:=5 step 5 until 25 do
OUTINTEGER(i)
```

## ALGOL 68

The ALGOL 68 "universal" for/while loop:

``` [ for index ] [ from first ] [ by increment ] [ to last ] [ while condition ] do statements od
The minimum form of a "loop clause" is thus: do statements od # an infinite loop #
```

The formal specification of ALGOL 68 states:

```for i from u1 by u2 to u3 while condition do action od
```

"is thus equivalent to the following void-closed-clause:"

```begin int f:= u1, int b = u2, t = u3;
step2:
if (b > 0 ∧ f ≤ t) ∨ (b < 0 ∧ f ≥ t) ∨ b = 0
then int i = f;
if condition
then action; f +:= b; go to step2
fi
fi
end
```

Note: Highlighting is as per the formal specification, c.f. Category:ALGOL 68#Example of different program representations.

There are several unusual aspects of the construct:

• only the 'do ~ od' portion was compulsory, in which case the loop will iterate indefinitely.
• thus the clause 'to 100 do ~ od', will iterate only 100 times.
• the while "syntactic element" allowed a programmer to break from a for loop early. eg
```int sum sq:=0;
for i while
sum sq ≠ 70 × 70
do
sum sq +:= i ↑ 2
od
```

Subsequent "extensions" to the standard Algol68 allowed the to syntactic element to be replaced with upto and downto to achieve a small optimisation. The same compilers also incorporated:

• until(C) - for late loop termination.
• foreach(S) - for working on arrays in parallel.

## ALGOL-M

`BEGIN    INTEGER I;    FOR I := 1 STEP 3 UNTIL 19 DO        WRITE( I );END`

## ALGOL W

`begin    for i := 3 step 2 until 9 do write( i )end.`

## AppleScript

`repeat with i from 2 to 10 by 2	log iend repeat`

## ARM Assembly

Works with: as version Raspberry Pi
`  /* ARM assembly Raspberry PI  *//*  program loopstep2.s   */ /* Constantes    */.equ STDOUT, 1     @ Linux output console.equ EXIT,   1     @ Linux syscall.equ WRITE,  4     @ Linux syscall.equ MAXI,   20/*********************************//* Initialized data              *//*********************************/.dataszMessResult:  .ascii "Counter = "      @ message resultsMessValeur:   .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,#01:    @ 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    add r4,#2                   @ increment counter by 2    cmp r4,#MAXI              @    ble 1b                @ loop 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 sMessValeuriAdrszMessResult:         .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 *//***************************************************//* integer division unsigned                       *//***************************************************/division:    /* r0 contains dividend */    /* r1 contains divisor */    /* r2 returns quotient */    /* r3 returns remainder */    push {r4, lr}    mov r2, #0                @ init quotient    mov r3, #0                @ init remainder    mov r4, #32               @ init counter bits    b 2f1:          @ loop     movs r0, r0, LSL #1     @ r0 <- r0 << 1 updating cpsr (sets C if 31st bit of r0 was 1)    adc r3, r3, r3           @ r3 <- r3 + r3 + C. This is equivalent to r3 ? (r3 << 1) + C     cmp r3, r1               @ compute r3 - r1 and update cpsr     subhs r3, r3, r1        @ if r3 >= r1 (C=1) then r3 ? r3 - r1     adc r2, r2, r2           @ r2 <- r2 + r2 + C. This is equivalent to r2 <- (r2 << 1) + C 2:    subs r4, r4, #1          @ r4 <- r4 - 1     bpl 1b                  @ if r4 >= 0 (N=0) then loop    pop {r4, lr}    bx lr   `

## Arturo

`loop [rangeBy 0 10 2] {	print &}`
Output:
```0
2
4
6
8
10```

## AutoHotkey

`SetBatchLines, -1iterations := 5step := 10iterations *= stepLoop,  % iterations{   If Mod(A_Index, step)      Continue   MsgBox, % A_Index}ExitApp`

## AWK

`BEGIN {  for (i= 2; i <= 8; i = i + 2) {    print i  }  print "Ain't never too late!"}`

## Axe

Axe does not support a step size other than 1. However, one can modify the increment variable inside the loop to accomplish the same task.

This example increments by 2:

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

## BASIC

### Applesoft BASIC

`FOR I = 2 TO 8 STEP 2 : PRINT I; ", "; : NEXT I : PRINT "WHO DO WE APPRECIATE?"`

### BaCon

This prints all odd digits:

` FOR i = 1 TO 10 STEP 2    PRINT iNEXT`

### Basic

Works with: QuickBasic version 4.5
`FOR i = 2 TO 8 STEP 2   PRINT i; ", ";NEXT iPRINT "who do we appreciate?"`

### IS-BASIC

`100 FOR I=1 TO 10 STEP 2110   PRINT I120 NEXT`

### smart BASIC

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

`FOR n = 2 TO 8 STEP 2   PRINT n & "..";NEXT nPRINT "who do we appreciate?"END`

### Commodore BASIC

`10 FOR I = 1 TO 10 STEP 220 PRINT I30 NEXT`

## Batch File

`@echo offfor /l %%A in (1,2,10) do (     echo %%A)`
Output:
```>Sample.BAT
1
3
5
7
9

>```

## BBC BASIC

`      FOR n = 2 TO 8 STEP 1.5        PRINT n      NEXT`
Output:
```         2
3.5
5
6.5
8
```

## bc

`for (i = 2; i <= 10; i += 2) {    i}`

## Befunge

Translation of: C
`1 >:.55+,v@_^#`9:+2<`

## C

This prints all odd digits:

`int i;for(i = 1; i < 10; i += 2)  printf("%d\n", i);`

## ChucK

Chuck style

` SinOsc s => dac; for (0 => int i; i < 2000; 5 +=> i ){    i => s.freq;    100::ms => now;} `

General purpose style:

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

## C++

This prints all odd digits:

`for (int i = 1; i < 10; i += 2)  std::cout << i << std::endl;`

## C#

`using System; class Program {    static void Main(string[] args) {            for (int i = 2; i <= 8; i+= 2) {                    Console.Write("{0}, ", i);        }         Console.WriteLine("who do we appreciate?");    }}`

## Ceylon

`shared void run() { 	for(i in (2..8).by(2)) {		process.write("``i`` ");	}	print("who do we appreciate?");}`

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

`(loop [i 0]  (println i)  (when (< i 10)    (recur (+ 2 i)))) (doseq [i (range 0 12 2)]   (println i))`

## COBOL

`       IDENTIFICATION DIVISION.       PROGRAM-ID. Display-Odd-Nums.        DATA DIVISION.       WORKING-STORAGE SECTION.       01  I PIC 99.        PROCEDURE DIVISION.           PERFORM VARYING I FROM 1 BY 2 UNTIL 10 < I               DISPLAY I           END-PERFORM            GOBACK           .`

## ColdFusion

` <cfloop from="0" to="99" step="3" index="i">  <Cfoutput>#i#</Cfoutput></cfloop> `

## Common Lisp

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

## Chapel

` // Can be set on commandline via --N=xconfig const N = 3;  for i in 1 .. 10 by N {  writeln(i);} `
Output:
```\$ ./loopby
1
4
7
10

\$ ./loopby --N=4
1
5
9
```

## D

`import std.stdio, std.range; void main() {    // Print odd numbers up to 9.    for (int i = 1; i < 10; i += 2)        writeln(i);     // Alternative way.    foreach (i; iota(1, 10, 2))        writeln(i);}`
Output:
```1
3
5
7
9
1
3
5
7
9```

## Dao

`# first value: 1# max value: 9# step: 2for( i = 1 : 2 : 9 ) io.writeln( i )`

## Delphi

Delphi's For loop doesn't support a step value. It would have to be simulated using something like a While loop.

`program LoopWithStep; {\$APPTYPE CONSOLE} var  i: Integer;begin  i:=2;  while i <= 8 do begin    WriteLn(i);    Inc(i, 2);  end;end.`
Output:
```2
4
6
8```

## Dragon

`for(i = 2, i <= 8,i += 2){   show i + ", "}showln "who do we appreciate?"`

## DWScript

`var i : Integer; for i := 2 to 8 step 2 do   PrintLn(i);`
Output:
```2
4
6
8```

## 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:

`var i := 2while (i <= 8) {    print(`\$i, `)    i += 2}println("who do we appreciate?")`

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

`def stepRange(low, high, step) {    def range {        to iterate(f) {            var i := low            while (i <= high) {                f(null, i)                i += step            }        }    }    return range} for i in stepRange(2, 9, 2) {  print(`\$i, `)}println("who do we appreciate?")`

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

`for i ? (i %% 2 <=> 0) in 2..8 {    print(`\$i, `)}println("who do we appreciate?")`

## 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 ((q (in-range 0 15 14/8))) (write q))    0 7/4 7/2 21/4 7 35/4 21/2 49/4 14  (for ((x (in-range 0 15 PI))) (write x))    0 3.141592653589793 6.283185307179586 9.42477796076938 12.566370614359172  `

## Ela

`open monad io for m s n | n > m = do return ()          | else = do              putStrLn (show n)               for m s (n+s) _  = for 10 2 0 ::: IO`
Output:
```0
2
4
6
8
10```

## Elena

ELENA 4.x

`public program(){    for(int i := 2, i <= 8, i += 2  )    {        console.writeLine:i    }}`

## Elixir

`defmodule Loops do  def for_step(n, step) do    IO.inspect Enum.take_every(1..n, step)  endend Loops.for_step(20, 3)`
Output:
```[1, 4, 7, 10, 13, 16, 19]
```

or

`iex(1)> Stream.iterate(1, &(&1+2)) |> Enum.take(10)[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]`

## ERRE

`       FOR N=2 TO 8 STEP 1.5 DO        PRINT(N)      END FOR `
Output:
```         2
3.5
5
6.5
8
```

## Erlang

`%% Implemented by Arjun Sunel%% for_loop/4 by Bengt Kleberg.-module(loop_step).-export([main/0, for_loop/1, for_loop/4]).  % This Erlang code for "For Loop" is equivalent to: " for (i=start;  i<end ; i=i+2){ printf("* ");} " in C language.  main() ->	for_loop(1).      for_loop( N ) ->	for_loop( N, 4, 2, fun() -> io:fwrite("* ") end ). for_loop( I, End, Step, Do ) when N < End ->    Do(),    for_loop( I+Step, End, Step, Do );for_loop( _I, _End, _Step, _Do ) -> ok. `
Output:
```* * ok
```

## Euphoria

` for i = 1 to 10 by 2 do    ? iend for `

As a note, `? something` is shorthand for:

` print(1, something)puts(1, "\n") `

`print()` differs from `puts()` in that `print()` will print out the actual `sequence` it is given. If it is given an `integer`, or an `atom` (Any number that is not an `integer`), it will print those out as-is.

## Factor

Prints odd digits.

`1 10 2 <range> [ . ] each`

## FALSE

`2[\$9\>][\$.", "2+]#"who do we appreciate!"`

## Fantom

` class Main{  public static Void main ()  {    Int step := 5    for (Int i := 0; i < 100; i += step)    {      echo (i)    }  }} `

## FBSL

`#APPTYPE CONSOLE DIM n AS INTEGERFOR n = 2 TO 8 STEP 2    PRINT n;    IF n < 8 THEN PRINT " ";NEXTPRINT ", who will we obliterate?"PAUSE `

## FOCAL

If a FOR 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.

`FOR I = 1,3,10; TYPE I, !`

## Forth

`: test  9 2 do    i .  2 +loop  ." who do we appreciate?" cr ;`

## Fortran

Works with: Fortran version 90 and later
`do i = 1,10,2   print *, iend do`
Works with: Fortran version 77 and later
`      PROGRAM STEPFOR        INTEGER I C       This will print all even numbers from -10 to +10, inclusive.        DO 10 I = -10, 10, 2          WRITE (*,*) I   10   CONTINUE         STOP      END`

## FreeBASIC

`' FB 1.05.0 Win64 For i As Integer = 1 To 21 Step 2  Print i; " ";NextPrintSleep`
Output:
``` 1  3  5  7  9  11  13  15  17  19  21
```

## F#

`for i in 2..2..8 do   printf "%d, " iprintfn "done"`
Output:
```2, 4, 6, 8, done
```

## FutureBasic

` include "ConsoleWindow" dim as Str15 s(11)dim as long i s(0) = "Somewhere"s(2) = " over"s(4) = " the"s(6) = " rainbow" + chr\$(13)s(8) = "Bluebirds"s(10) = " fly." for i = 0 to 10 step 2print s(i);next `

Output:

```Somewhere over the rainbow
Bluebirds fly.
```

## Gambas

`Public Sub Main()Dim siCount As Short For siCount = 1 To 50 Step 5  Print "Gambas is great!"Next End`
```Gambas is great!
Gambas is great!
Gambas is great!
Gambas is great!
Gambas is great!
Gambas is great!
Gambas is great!
Gambas is great!
Gambas is great!
Gambas is great!
```

## GAP

1. 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.
`for i in [1, 3 .. 11] do    Print(i, "\n");od; 1357911 `

## GML

`for(i = 0; i < 10; i += 2)    show_message(string(i))`

## Go

This prints all odd digits:

`for i := 1; i < 10; i += 2 {  fmt.Printf("%d\n", i)}`

## Groovy

"for" loop:

`for(i in (2..9).step(2)) {    print "\${i} "}println "Who do we appreciate?"`

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

`(2..9).step(2).each {    print "\${it} "}println "Who do we appreciate?"`
Output:
`2 4 6 8 Who do we appreciate?`

Go Team!

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

`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(2, 8, 2)) {      Sys.print('\$i ');    }    Sys.println('WHOM do we appreciate? GRAMMAR! GRAMMAR! GRAMMAR!');  }}`
Output:
`2 4 6 8 WHOM do we appreciate? GRAMMAR! GRAMMAR! GRAMMAR!`

`import Control.Monad (forM_)main = do forM_ [2,4..8] (\x -> putStr (show x ++ ", "))          putStrLn "who do we appreciate?"`

## hexiscript

`for let i 0; i <= 50; let i (i + 5)  println iendfor`

## HicEst

`DO i = 1, 6, 1.25 ! from 1 to 6 step 1.25   WRITE() iENDDO`

## Icon and 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 1 to 10                            # no to, step is by 1 by default   every EXPR1 to EXPR2 by EXPR3 do EXPR4   # general case - EXPRn can be complete expressions including other generators such as to-by, every's do is optional   steps := [2,3,5,7]                       # a list   every i := 1 to 100 by !steps            # . more complex, several passes with each step in the list steps, also we might want to know what value we are at   every L[1 to 100 by 2]                   # as a list index   every i := 1 to 100 by (k := !steps)     # . need () otherwise := generates an error   every 1 to 5 to 10                       # simple case of combined to-by - 1,..,10, 2,..10, ..., 5,..,10   every 1 to 15 by 2 to 5                  # combined to-by   every (1 to 15 by 2) to 5                # . made explicit    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. In cases where the by is used it might seem more natural to be right associative. If in doubt parenthesize.

## HolyC

This prints all odd digits:

`U8 i;for (i = 1; i < 10; i += 2)  Print("%d\n", i);`

## Io

`for(i,2,8,2,    write(i,", "))write("who do we appreciate?")`

## J

`    ' who do we appreciate?' ,~ ":  2 * >: i.42 4 6 8 who do we appreciate?`

Or, using an actual for loop:

`   3 :0''  r=.\$0  for_n. 2 * >: i.4 do.    r=.r,n  end.  ' who do we appreciate?' ,~ ":n)2 4 6 8 who do we appreciate?`

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

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

Or, if we prefer, we could borrow the definition of `thru` from the Downward for task and then filter for the desired values:

`   thru=: <./ + [email protected](+*)@-~`

Example use:

`   (#~ 0 = 2&|) 1 thru 202 4 6 8 10 12 14 16 18 20   (#~ 0 = 3&|) 1 thru 203 6 9 12 15 18   (#~ 1 = 3&|) 1 thru 201 4 7 10 13 16 19`

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

`   (#~ 1&p:) 1 thru 202 3 5 7 11 13 17 19`

## Java

`for(int i = 2; i <= 8;i += 2){   System.out.print(i + ", ");}System.out.println("who do we appreciate?");`

## JavaScript

`var output = '',    i;for (i = 2; i <= 8; i += 2) {   output += i + ', ';}output += 'who do we appreciate?';document.write(output);`

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(iMax)// range(iMin, iMax)// range(iMin, iMax, dI)function range() {  var lngArgs = arguments.length,    lngMore = lngArgs - 1;   iMin = lngMore ? arguments : 1;  iMax = arguments[lngMore ? 1 : 0];  dI = lngMore > 1 ? arguments : 1;   return lngArgs ? Array.apply(null, Array(    Math.floor((iMax - iMin) / dI) + 1  )).map(function (_, i) {    return iMin + (dI * i);  }) : [];} console.log(  range(2, 8, 2).join(', ') + ', who do we appreciate ?');`

Output:

`2, 4, 6, 8, who do we appreciate ?`

## jq

To generate the stream: 2,4,6,8:
`# If your version of jq does not have range/3, use this:def range(m;n;step): range(0; ((n-m)/step) ) | m + (. * step); range(2;9;2)`

Example:

`reduce range(2;9;2) as \$i   (""; . + "\(\$i), ") +   "whom do we appreciate?"`

## Julia

`for i in 2:2:8    print(i, ", ")endprintln("whom do we appreciate?")`

## Kotlin

`// version 1.0.6 fun main(args: Array<String>) {    for (i in 1 .. 21 step 2) print("\$i ")}`
Output:
```1 3 5 7 9 11 13 15 17 19 21
```

## LabVIEW

This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code. ## Lang5

`: <range>  over iota swap * rot + tuck swap <= select ; : tuck  swap over ;: >>say.(*)  . ;1 10 2 <range> >>say.`

## langur

`for .i = 1; .i < 10; .i += 2 {    writeln .i}`
Output:
```1
3
5
7
9```

## Lasso

`loop(-to=100, -from=1, -by=2) => {^    loop_count    '\r' // for formatting^}`

## Liberty BASIC

` for i = 2 to 8 step 2   print i; ", ";next iprint "who do we appreciate?"end `

## LIL

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

`for {set i 1} {\$i < 15} {inc i 3} {print \$i}`
Output:
```# for {set i 1} {\$i < 15} {inc i 3} {print \$i}
1
4
7
10
13
#```

## Lingo

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

`step = 3repeat with i = 0 to 10  put i  i = i + (step-1)end repeat`
Output:
```-- 0
-- 3
-- 6
-- 9
```

## Lisaac

`1.to 9 by 2 do { i : INTEGER;  i.print;  '\n'.print;};`

## LiveCode

`repeat with n = 0 to 10 step 2    put n after loopn    if n is not 10 then put comma after loopnend repeatput loopn`
Output
`0,2,4,6,8,10`

## Logo

`for [i 2 8 2] [type :i type "|, |] print [who do we appreciate?]`

## Lua

` for i=2,9,2 do  print(i)end `
Output:
```2
4
6
8
```

## M2000 Interpreter

### A for loop

Str\$(i) always return decimal separator as "." format\$() use same as Locale number specify. So here we use "," from Locale 1036. Str\$() place a space before number if it is positive. We can use str\$(i, "") to trim lead space. Here we use a space in format\$ before number (and for negative numbers)

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      Document doc\$      \\ define i as a single      def single i      for i=1 to 21 step 5/3            Print i            doc\$=format\$(" {0}", i)      next i      doc\$={      }      \\ make i as a single      for i=21 to 1 step 5/3            Print i            doc\$=format\$(" {0}", i)      next i      clipboard doc\$      report doc\$}LoopFor `
Output:
``` 1 2,66667 4,33333 6 7,66667 9,33333 11 12,66667 14,33333 16 17,66667 19,33333 21
21 19,33333 17,66667 16 14,33334 12,66667 11 9,33333 7,66667 6 4,33333 2,66667 1
```

### Iterator step 2

` a=("A", "B", "C", "D", "E", "F", "Z")k=Each(a)While k {      Print Array\$(k),      k=Each(a, k^+2)   ' set start again}Print\\ a list of keys (unique keys allowed)Inventory b="A", "B", "C", "D", "E", "F", "Z"k=Each(b)While k {      Print Eval\$(k), ' return keys as values, because no value exist yet for each key.      k=Each(b, k^+2)}Print `
Output:
```A   C   E   Z
A   C   E   Z
```

## 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',`1',`5',`3',`x') `
Output:
```1
4
```

## Maple

`for i from 2 to 8 by 2 do  i;end do;`
Output:
```                               2
4
6
8
```

## Mathematica

`Do[ [email protected], {i, 1, 20, 4}]`
Output:
```1
5
9
13
17
```

## MATLAB / Octave

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

A vectorized version of the code is

`  printf('%d\n',0:10:100);  `

## Maxima

`for i: 1 step 2 thru 10 do print(i);/* 1   3   5   7 */`

## MAXScript

`for i = 0 to 10 by 2 do format "%\n" i`

Output:

` 0246810OK `

## Microsoft Small Basic

` For i = 0 To 100 Step 2  TextWindow.WriteLine(i)EndFor `

## MiniScript

`for i in range(1,20,4)    print iend for`
Output:
```1
5
9
13
17```

## МК-61/52

`1	П0	ИП0	3	+	П0	1	0	-	x#002	С/П`

In this example, the step is 3, the lowest value is 1 and the upper limit is 10.

## Modula-2

`MODULE ForBy;  IMPORT InOut;   VAR    i: INTEGER; BEGIN  FOR i := 0 TO 100 BY 2 DO    InOut.WriteInt(i, 3);    InOut.WriteLn  ENDEND ForBy.`

## Modula-3

`FOR i := 1 TO 100 BY 2 DO  IO.Put(Fmt.Int(i) & " ");END;`

## MUMPS

`FOR I=65:3:122 DO .WRITE \$CHAR(I)," "`
Output:
`A D G J M P S V Y \ _ b e h k n q t w z`

## NewLISP

`(for (i 0 10 2)  (println i))`

## Nim

`for x in countdown(10,0,3): echo(x)`
Output:
```10
7
4
1```

## Nemerle

`for (i = 2; i <= 8; i +=2)`
`foreach (i in [2, 4 .. 8])`

## NetRexx

`/* NetRexx */options replace format comments java crossref savelog symbols nobinary say  say 'Loops/For with a specified step'   loop i_ = -1.4 to 10.6 by 1.7    say i_.format(3, 1) || '\0'    end i_  say`
Output:
```D:\>java lst

Loops/For with a specified step
-1.4  0.3  2.0  3.7  5.4  7.1  8.8 10.5```

## Never

The increment step of the Never for expression can be simple or complex and need not be contiguous.

`for (i = 0; i < 10; i += 3)`

## NS-HUBASIC

`10 FOR I=1 TO 10 STEP 220 PRINT I30 NEXT`

## Oberon-2

Works with oo2c Version 2

` MODULE LoopForStep;IMPORT   Out;VAR  i: INTEGER; BEGIN  FOR i := 0 TO 10 BY 3 DO    Out.LongInt(i,0);Out.Ln  END;  FOR i := 10 TO 0 BY -3 DO    Out.LongInt(i,0);Out.Ln  ENDEND LoopForStep. `

Output:

```0
3
6
9
10
7
4
1
```

## Objeck

` for(i := 0; i < 10; i += 2;) {  i->PrintLine();}; `

## OCaml

`# let for_step a b step fn =    let rec aux i =      if i <= b then begin        fn i;        aux (i+step)      end    in    aux a  ;;val for_step : int -> int -> int -> (int -> 'a) -> unit = <fun> # for_step 0 8 2  (fun i -> Printf.printf " %d\n" i) ;; 0 2 4 6 8- : unit = ()`

## Octave

`for i = 1:2:10  disp(i)endfor`

## Oforth

` 1 100 2 step: i [ i println ]`

`/* Loop from 3 to 9 in steps of 2 */ for ( l = [3:2:9] )  {  echo (l);}echo ("on a double white line.");`

## Oz

`for I in 2..8;2 do   {System.show I}end{System.show done} `

## PARI/GP

`forstep(n=1,10,2,print(n))`

The `forstep` construct is actually more powerful. For example, to print numbers with last digit relatively prime to 10:

`forstep(n=1,100,[2,4,2,2],print(n))`

## Panda

Panda doesn't nativly have a number generator with steps, so let's add it.

`fun for(from,to,step) type integer,integer,integer->integer  t=to.minus(from).divide(step)  0..t.times(step).plus(from)  /test it for(1 6 2) -> 1 3 5 for(1 3 5)`

See Delphi

## Perl

`for(\$i=2; \$i <= 8; \$i += 2) {  print "\$i, ";}print "who do we appreciate?\n";`

## Perl 6

Works with: Rakudo version 2010.07

With at least two values on the left-hand side, the sequence operator (`...`) can infer an arithmetic series. (With at least three values, it can infer a geometric sequence, too.)

`for 2, 4 ... 8 {    print "\$_, ";} say 'whom do we appreciate?';`

## Phix

`for i=2 to 8 by 2 do    printf(1,"%d, ",i)end forprintf(1,"who do we appreciate?\n")`

## PHP

`<?phpforeach (range(2, 8, 2) as \$i)    echo "\$i, ";echo "who do we appreciate?\n";?>`
Output:
`2, 4, 6, 8, who do we appreciate?`

## PicoLisp

`(for (N 1 (> 10 N) (+ N 2))   (printsp N) )`

## Pike

`int main() {   for(int i = 2; i <= 16; i=i+2) {      write(i + "\n");   }}`

## PILOT

One of the advantages of needing to create loops manually by using conditional jumps is that a step of any integer is just as easy as a step of one.

`R  : Prints the odd numbers less than 10.C  :i = 1*LoopT  :#iC  :i = i + 2J ( i < 10 )  :*LoopEND:`

## PL/I

` declare (n, i) fixed binary; get list (n);do i = 1 to n by 4;   put skip list (i);end; `

## PowerShell

`for (\$i = 0; \$i -lt 10; \$i += 2) {    \$i}`

## PureBasic

`For i=-15 To 25 Step 5  Debug iNext i`

## Prolog

If you need a stepping iterator, write one:

`for(Lo,Hi,Step,Lo)  :- Step>0, Lo=<Hi.for(Lo,Hi,Step,Val) :- Step>0, plus(Lo,Step,V), V=<Hi, !, for(V,Hi,Step,Val). example :-   for(0,10,2,Val), write(Val), write(' '), fail.example.`
```?- example.
0 2 4 6 8 10
true.```

Adding the following two rules lets you go backwards too:

`for(Hi,Lo,Step,Hi)  :- Step<0, Lo=<Hi.for(Hi,Lo,Step,Val) :- Step<0, plus(Hi,Step,V), Lo=<V, !, for(V,Lo,Step,Val).`

## Python

Works with: Python version 2.x
`for i in xrange(2, 9, 2):    print "%d," % i,print "who do we appreciate?"`
Works with: Python version 3.x
`for i in range(2, 9, 2):    print("%d, " % i, end="")print("who do we appreciate?")`
Output:
`2, 4, 6, 8, who do we appreciate?`

## R

`for(a in seq(2,8,2)) {  cat(a, ", ")}cat("who do we appreciate?\n")`

Here the loop may be done implicitly by first concatenating the string and then printing:

`cat(paste(c(seq(2, 8, by=2), "who do we appreciate?\n"), collapse=", "))`

## Racket

` #lang racket (for ([i (in-range 2 9 2)])  (printf "~a, " i))(printf "who do we appreciate?~n") `

## Raven

List of numbers:

`[ 2 4 6 8 ] each "%d, " print"who do we appreciate?\n" print`

Range:

`2 10 2 range each "%d, " print"who do we appreciate?\n" print`
Output:
```2, 4, 6, 8, who do we appreciate?
```

## REBOL

`for i 2 8 2 [	prin rejoin [i ", "]]print "who do we appreciate?"`
Output:
`2, 4, 6, 8, who do we appreciate?`

## REXX

### version 1

`  do x=1  to 10  by 1.5  say x  end`
Output:
```1
2.5
4.0
5.5
7.0
8.5
10.0
```

### version 2

`  do thing=1  by  3/2  to 10   say  thing  end`

output is the same as above.

### version 3

`Do v=1  by  3/2  While v**2<30   Say  v  EndSay '('v'**2) is greater than 30 (30.25)'`
Output:
```1
2.5
4.0
(5.5**2) is greater than 30 (30.25)```

## Ring

we use step keyword to define step length in this example we print Even numbers between 0 and 10

` for i = 0 to 10 step 2 see i + nl next `
Output:
```2
4
6
8
10
```

we can use step with double values as well:

` for i = 0 to 10 step 0.5 see i + nl next `
Output:
```0
0.50
1
1.50
2
2.50
3
3.50
4
4.50
5
5.50
6
6.50
7
7.50
8
8.50
9
9.50
10
```

## Ruby

`2.step(8,2) {|n| print "#{n}, "}puts "who do we appreciate?"`

or:

`(2..8).step(2) {|n| print "#{n}, "}puts "who do we appreciate?"`

or:

`for n in (2..8).step(2)  print "#{n}, "endputs "who do we appreciate?"`
Output:
```2, 4, 6, 8, who do we appreciate?
```

## Run BASIC

`for i = 2 to 8 step 2   print i; ", ";next iprint "who do we appreciate?"`
Output:
`2, 4, 6, 8, who do we appreciate?`

## Rust

For Rust 1.28 and later:

`fn main() {  for i in (2..=8).step_by(2) {    print!("{}", i);  }  println!("who do we appreciate?!");} `

An alternative which also works in earlier versions of Rust:

`fn main() {    let mut i = 2;    while i <= 8 {        print!("{}, ", i);        i += 2;    }    println!("who do we appreciate?!");}`

## Salmon

`for (x; 2; x <= 8; 2)    print(x, ", ");;print("who do we appreciate?\n");`

## SAS

`data _null_;do i=1 to 10 by 2;put i;end;run;`

## Sather

See Loops/For#Sather: the implementation for `for!` allows to specify a step, even though the built-in `stepto!` can be used; an example of usage could be simply:

`    i :INT;    loop      i := for!(1, 50, 2);      -- OR      -- i := 1.stepto!(50, 2);      #OUT + i + "\n";    end;`

(Print all odd numbers from 1 to 50)

## Scala

`for (i <- 2 to 8 by 2) println(i)`

Alternatively:

`(2 to 8 by 2) foreach println`

## Scheme

The built-in for-like form in Scheme is the do form:

`(do ((i 2 (+ i 2)))  ; list of variables, initials and steps -- you can iterate over several at once  ((>= i 9))         ; exit condition  (display i)        ; body  (newline))`

Some people prefer to use the recursive-style and more flexible _named let_ form:

`(let loop ((i 2))            ; function name, parameters and starting values  (cond ((< i 9)         (display i)         (newline)         (loop (+ i 2))))))  ; tail-recursive call, won't create a new stack frame`

You can add to the language by wrapping the loop in a function:

`(define (for-loop start end step func)  (let loop ((i start))    (cond ((< i end)	   (func i)	   (loop (+ i step)))))) (for-loop 2 9 2  (lambda (i)    (display i)    (newline)))`

... or in a macro, which allows for making the `(lambda)` implicit:

`(define-syntax for-loop  (syntax-rules ()     ((for-loop index start end step body ...)     (let ((evaluated-end end) (evaluated-step step))       (let loop ((i start))         (if (< i evaluated-end)           ((lambda (index) body ... (loop (+ i evaluated-step))) i))))))) (for-loop i 2 9 2  (display i)  (newline))`
Output:
```2
4
6
8```

## Scilab

Works with: Scilab version 5.5.1
`for i=1:2:10    printf("%d\n",i)end`
Output:
```1
3
5
7
8```

## Seed7

`\$ include "seed7_05.s7i"; const proc: main is func  local    var integer: number is 0;  begin    for number range 1 to 10 step 2 do      writeln(number);    end for;  end func;`

## Sidef

for(;;) loop:

`for (var i = 2; i <= 8; i += 2) {    say i}`

for-in loop:

`for i in (2 .. (8, 2)) {    say i}`

.each method:

`2.to(8).by(2).each { |i|    say i}`

## Simula

`begin    integer i;    for i:=5 step 5 until 25 do outint(i, 5)end`

## Slate

`2 to: 8 by: 2 do: [| :i | Console ; i printString ; ', '].inform: 'enough with the cheering already!'.`

## Smalltalk

`2 to: 8 by: 2 do: [ :i |  Transcript show: i; show ', '].Transcript showCr: 'enough with the cheering already!'`

## 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 0 to 19 step 3    ser.dec(n)    ser.tx(32)   waitcnt(_clkfreq + cnt)  ser.stop  cogstop(0)`
Output:
```0 3 6 9 12 15 18
```

## SPL

`> n, 1..10,2  #.output(n)<`

## SSEM

Implementing loops with a step other than one is precisely as easy (or as fiddly) as implementing loops with a step equal to one. This example program uses a loop to perform integer division. It should be run with the dividend in storage location 21 and the divisor in storage location 22. To show that it works, we shall ask the machine to count from 387 in steps of -5 and to halt with the accumulator showing the number of times it has done so before producing a negative result.

`10101000000000100000000000000000   0. -21 to c00101000000001100000000000000000   1. c to 2000101000000000100000000000000000   2. -20 to c01101000000000010000000000000000   3. Sub. 2210101000000001100000000000000000   4. c to 2100000000000000110000000000000000   5. Test01001000000001000000000000000000   6. Add 18 to CI00011000000000000000000000000000   7. 24 to CI11101000000000100000000000000000   8. -23 to CI01001000000000010000000000000000   9. Sub. 1800101000000001100000000000000000  10. c to 2000101000000000100000000000000000  11. -20 to c11101000000001100000000000000000  12. c to 2311001000000000000000000000000000  13. 19 to CI11101000000000100000000000000000  14. -23 to c00101000000001100000000000000000  15. c to 2000101000000000100000000000000000  16. -20 to c00000000000001110000000000000000  17. Stop10000000000000000000000000000000  18. 111111111111111111111111111111111  19. -100000000000000000000000000000000  20. 011000001100000000000000000000000  21. 38710100000000000000000000000000000  22. 500000000000000000000000000000000  23. 010110000000000000000000000000000  24. 13`

After executing 1,012 instructions, the computer halts with the correct quotient—77—in the accumulator.

## Stata

`forvalues i=1(2)10 {	display "`i'"} 13579`

## Swift

This prints all odd digits:

`for i in 1.stride(to: 10, by: 2) {  print(i)}`

Alternately (removed in Swift 3):

`for var i = 1; i < 10; i += 2 {  print(i)}`

## Tcl

`for {set i 2} {\$i <= 8} {incr i 2} {    puts -nonewline "\$i, "}puts "enough with the cheering already!"`

## TI-83 BASIC

Prints numbers from 0 to 100 stepping by 5.

`:For(I,0,100,5:Disp I:End`

## TI-89 BASIC

`Local iFor i, 0, 100, 5    Disp iEndFor`

## TorqueScript

`for(%i = 0; %i < 201; %i += 2){	echo(%i);}`

## TUSCRIPT

` \$\$ MODE TUSCRIPTLOOP i=2,9,2PRINT iENDLOOP `
Output:
```2
4
6
8
```

## UNIX Shell

All these loops iterate 2, 4, 6, 8.

### Bourne Shell

Works with: Bourne Shell
`x=2while test \$x -le 8; do	echo \$x	x=`expr \$x + 2` || exit \$?done`
Works with: Bourne Shell
Library: jot
`for x in `jot - 2 8 2`; do echo \$x; done`

### Korn Shell

Works with: Korn Shell
`x=2while [[\$x -le 8]]; do	echo \$x	((x=x+2))done`
Works with: Korn Shell
`x=2while ((x<=8)); do	echo \$x	((x+=2))done`

### Bourne Again Shell

Works with: Bourne Again SHell version 3
`for (( x=2; \$x<=8; x=\$x+2 )); do  printf "%d, " \$xdone`
Works with: Bourne Again SHell version 4

Bash v4.0+ has inbuilt support for setting up a step value

`for x in {2..8..2} do  echo \$xdone`

### C Shell

Library: jot
`foreach x (`jot - 2 8 2`)	echo \$xend`

## Ursa

Translation of: Python
`decl int ifor (set i 2) (< i 9) (set i (int (+ i 2)))	out i ", " consoleend forout "who do we appreciate?" endl console`

## Vala

`for (int i = 1; i < 10; i += 2)  stdout.printf("%d\n", i);`

## VAX Assembly

`                               0000  0000     1 .entry	main,0                            50   D4  0002     2 	clrf	r0				;init to 0.0                                     0004     3 loop:                                 01  0004     4 	nop					;do nothing             FFF9 50   0A   3E   4F  0005     5 	acbf	#112.0, #1.25, r0, loop		;limit, step                                     000B     6                                  04  000B     7 	ret                                     000C     8 .end	main`

## Vedit macro language

This prints all odd digits in range 1 to 9:

`for (#1 = 1; #1 < 10; #1 += 2) {    Num_Type(#1)}`

## VBA

`Sub MyLoop()    For i = 2 To 8 Step 2        Debug.Print i;    Next i    Debug.PrintEnd Sub`
Output:
``` 2  4  6  8
```

## VBScript

`buffer = ""For i = 2 To 8 Step 2    buffer = buffer & i & " "NextWScript.Echo buffer`
Output:
`2 4 6 8`

## Vim Script

`for i in range(2, 10, 2)    echo iendfor`
Output:
```2
4
6
8
10```

## Visual Basic

Works with: Visual Basic version VB6 Standard
`Sub MyLoop()    For i = 2 To 8 Step 2        Debug.Print i;    Next i    Debug.PrintEnd Sub`
Output:
``` 2  4  6  8
```

## Visual Basic .NET

Works with: Visual Basic .NET version 2011
`Public Class FormPG    Private Sub FormPG_Load(sender As Object, e As EventArgs) Handles MyBase.Load        Dim i As Integer, buffer As String        buffer = ""        For i = 2 To 8 Step 2            buffer = buffer & i & " "        Next i        Debug.Print(buffer)    End SubEnd Class`
Output:
```2 4 6 8
```

## Vorpal

`for(i = 2, i <= 8, i = i + 2){   i.print()}`

## Wart

`for i 2 (i <= 8) (i <- i+2)  prn i`

## XPL0

The 'for' loop always steps by 1 (or -1 for 'downto'). However there is no restriction on how the control variable can be used or manipulated, thus a step by 2 can be implemented like this:

`include c:\cxpl\codes;int I;[for I:= 2 to 8 do        [IntOut(0, I);  Text(0, ", ");        I:= I+1;        ];Text(0, "who do we appreciate?");]`
Output:
```2, 4, 6, 8, who do we appreciate?
```

## zkl

`foreach n in ([1..10,4]) {println(n)}[1..10,3].pump(Console.println)`
Output:
```1
5
9

1
4
7
10
```

A few others:

`fcn loop(i=0){println(i); if(i<10)return(self.fcn(i+2))}(0).pump(10,Console.println,fcn(n){if(n%2)return(Void.Skip); n})`

## ZX Spectrum Basic

`10 FOR l = 2 TO 8 STEP 220 PRINT l; ", ";30 NEXT l40 PRINT "Who do we appreciate?"`