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. <lang 360asm>* Loops/For with a specified step 12/08/2015 LOOPFORS 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 25
LOOPI 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 i
ELOOPI XPRNT BUF,80 print buffer
BR R14
BUF DC CL80' ' buffer XDEC DS CL12 temp for edit
YREGS END LOOPFORS</lang>
- 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. <lang 360asm>* == 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 25
LOOPJ 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</lang>
- Structured Macros
<lang 360asm>* == 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</lang>
- Structured Macros HLASM
<lang 360asm>* == 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</lang>
Ada
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.
<lang ada>with Loopers; use Loopers;
procedure For_Main is
begin
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;
</lang>
Aime
<lang aime>integer i;
i = 0; while (i < 10) {
o_winteger(2, i); i += 2;
}
o_newline();</lang>
ALGOL 60
<lang algol60> FOR i:=5 UNTIL 25 STEP 5 DO
OUTINTEGER(i)
</lang>
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 W
<lang algolw>begin
for i := 3 step 2 until 9 do write( i )
end.</lang>
AppleScript
<lang AppleScript>repeat with i from 2 to 10 by 2 log i end repeat</lang>
AutoHotkey
<lang AutoHotkey>SetBatchLines, -1 iterations := 5 step := 10 iterations *= step Loop, % iterations {
If Mod(A_Index, step) Continue MsgBox, % A_Index
} ExitApp</lang>
AWK
<lang awk>BEGIN {
for (i= 2; i <= 8; i = i + 2) { print i } print "Ain't never too late!"
}</lang>
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: <lang axe>For(I,0,10)
Disp I▶Dec,i I++
End</lang>
BASIC
Applesoft BASIC
<lang qbasic>FOR I = 2 TO 8 STEP 2 : PRINT I; ", "; : NEXT I : PRINT "WHO DO WE APPRECIATE?"</lang>
Basic
<lang qbasic>for i = 2 to 8 step 2
print i; ", ";
next i print "who do we appreciate?"</lang>
Batch File
<lang dos>@echo off for /l %%A in (1,2,10) do (
echo %%A
)</lang>
- Output:
>Sample.BAT 1 3 5 7 9 >
BBC BASIC
<lang bbcbasic> FOR n = 2 TO 8 STEP 1.5
PRINT n NEXT</lang>
- Output:
2 3.5 5 6.5 8
bc
<lang bc>for (i = 2; i <= 10; i += 2) {
i
}</lang>
Befunge
<lang befunge>1 >:.55+,v @_^#`9:+2<</lang>
C
This prints all odd digits: <lang c>int i; for(i = 1; i < 10; i += 2)
printf("%d\n", i);</lang>
ChucK
Chuck style <lang c> SinOsc s => dac;
for (0 => int i; i < 2000; 5 +=> i ) {
i => s.freq; 100::ms => now;
} </lang> General purpose style: <lang c> for (0 => int i; i < 2000; 5 +=> i ) {
<<< i >>>;
} </lang>
C++
This prints all odd digits: <lang cpp>for (int i = 1; i < 10; i += 2)
std::cout << i << std::endl;</lang>
C#
<lang csharp>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?"); }
}</lang>
Ceylon
<lang ceylon>shared void run() {
for(i in (2..8).by(2)) { process.write("``i`` "); } print("who do we appreciate?"); }</lang>
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. <lang Clojure>(loop [i 0]
(println i) (when (< i 10) (recur (+ 2 i))))
(doseq [i (range 0 12 2)]
(println i))</lang>
COBOL
<lang 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 .</lang>
ColdFusion
<lang cfm> <cfloop from="0" to="99" step="3" index="i">
<Cfoutput>#i#</Cfoutput>
</cfloop> </lang>
Common Lisp
<lang lisp> (format t "~{~S, ~}who do we appreciate?~%" (loop for i from 2 to 8 by 2 collect i)) </lang>
- Output:
2, 4, 6, 8, who do we appreciate?
Chapel
<lang chapel> // Can be set on commandline via --N=x config const N = 3;
for i in 1 .. 10 by N {
writeln(i);
} </lang>
- Output:
$ ./loopby 1 4 7 10 $ ./loopby --N=4 1 5 9
D
<lang 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);
}</lang>
- Output:
1 3 5 7 9 1 3 5 7 9
Dao
<lang dao># first value: 1
- max value: 9
- step: 2
for( i = 1 : 2 : 9 ) io.writeln( i )</lang>
Delphi
Delphi's For loop doesn't support a step value. It would have to be simulated using something like a While loop.
<lang Delphi>program LoopWithStep;
{$APPTYPE CONSOLE}
var
i: Integer;
begin
i:=2; while i <= 8 do begin WriteLn(i); Inc(i, 2); end;
end.</lang>
- Output:
2 4 6 8
DWScript
<lang Delphi>var i : Integer;
for i := 2 to 8 step 2 do
PrintLn(i);</lang>
- 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:
<lang e>var i := 2 while (i <= 8) {
print(`$i, `) i += 2
} println("who do we appreciate?")</lang>
A programmer frequently in need of iteration with an arbitrary step should define an appropriate range object:
<lang e>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?")</lang>
The least efficient, but perhaps convenient, solution is to iterate over successive integers and discard undesired ones:
<lang e>for i ? (i %% 2 <=> 0) in 2..8 {
print(`$i, `)
} println("who do we appreciate?")</lang>
EchoLisp
Steps may be integers, float, rationals. <lang lisp> (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
</lang>
Ela
<lang 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</lang>
- Output:
0 2 4 6 8 10
Elena
<lang elena>#import system.
- import extensions.
- symbol program =
[
2 to:8 &by:2 &doEach:i [ console writeLine:i. ].
]. </lang>
Elixir
<lang elixir>defmodule Loops do
def for_step(n, step) do IO.inspect Enum.take_every(1..n, step) end
end
Loops.for_step(20, 3)</lang>
- Output:
[1, 4, 7, 10, 13, 16, 19]
or <lang elixir>iex(1)> Stream.iterate(1, &(&1+2)) |> Enum.take(10) [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]</lang>
ERRE
<lang ERRE>
FOR N=2 TO 8 STEP 1.5 DO PRINT(N) END FOR
</lang>
- Output:
2 3.5 5 6.5 8
Erlang
<lang 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. </lang>
- Output:
* * ok
Euphoria
<lang Euphoria> for i = 1 to 10 by 2 do
? i
end for
</lang>
As a note, ? something
is shorthand for:
<lang Euphoria>
print(1, something)
puts(1, "\n")
</lang>
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. <lang factor>1 10 2 <range> [ . ] each</lang>
FALSE
<lang false>2[$9\>][$.", "2+]#"who do we appreciate!"</lang>
Fantom
<lang fantom> class Main {
public static Void main () { Int step := 5 for (Int i := 0; i < 100; i += step) { echo (i) } }
} </lang>
FBSL
<lang qbasic>#APPTYPE CONSOLE
DIM n AS INTEGER FOR n = 2 TO 8 STEP 2
PRINT n; IF n < 8 THEN PRINT " ";
NEXT PRINT ", who will we obliterate?" PAUSE </lang>
Forth
<lang forth>: test
9 2 do i . 2 +loop ." who do we appreciate?" cr ;</lang>
Fortran
<lang fortran>do i = 1,10,2
print *, i
end do</lang>
<lang fortran> 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</lang>
F#
<lang fsharp>for i in 2..2..8 do
printf "%d, " i
printfn "done"</lang>
- Output:
2, 4, 6, 8, done
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.
<lang gap>for i in [1, 3 .. 11] do
Print(i, "\n");
od;
1 3 5 7 9 11 </lang>
GML
<lang GML>for(i = 0; i < 10; i += 2)
show_message(string(i))</lang>
Go
This prints all odd digits: <lang go>for i := 1; i < 10; i += 2 {
fmt.Printf("%d\n", i)
}</lang>
Groovy
"for" loop: <lang groovy>for(i in (2..9).step(2)) {
print "${i} "
} println "Who do we appreciate?"</lang>
"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. <lang groovy>(2..9).step(2).each {
print "${it} "
} println "Who do we appreciate?"</lang>
- Output:
2 4 6 8 Who do we appreciate?
Go Team!
Haskell
<lang haskell>import Control.Monad (forM_) main = do forM_ [2,4..8] (\x -> putStr (show x ++ ", "))
putStrLn "who do we appreciate?"</lang>
HicEst
<lang hicest>DO i = 1, 6, 1.25 ! from 1 to 6 step 1.25
WRITE() i
ENDDO</lang>
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. <lang Icon>
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
</lang> 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.
Io
<lang Io>for(i,2,8,2,
write(i,", ")
) write("who do we appreciate?")</lang>
J
<lang J> ' who do we appreciate?' ,~ ": 2 * >: i.4 2 4 6 8 who do we appreciate?</lang>
Or, using an actual for loop:
<lang J> 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?</lang>
That said, note also that J's steps verb lets us specify how many steps to take:
<lang J> 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</lang>
Or, if we prefer, we could borrow the definition of thru
from the Downward for task and then filter for the desired values:
<lang J> thru=: <./ + i.@(+*)@-~</lang>
Example use:
<lang J> (#~ 0 = 2&|) 1 thru 20 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
1 4 7 10 13 16 19</lang>
And, of course, like filtering in any language, this approach supports non-constant step sizes:
<lang J> (#~ 1&p:) 1 thru 20 2 3 5 7 11 13 17 19</lang>
Java
<lang java>for(int i = 2; i <= 8;i += 2){
System.out.print(i + ", ");
} System.out.println("who do we appreciate?");</lang>
JavaScript
<lang javascript>var output = ,
i;
for (i = 2; i <= 8; i += 2) {
output += i + ', ';
} output += 'who do we appreciate?'; document.write(output);</lang>
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:
<lang JavaScript>// range(iMax) // range(iMin, iMax) // range(iMin, iMax, dI) function range() {
var lngArgs = arguments.length, lngMore = lngArgs - 1;
iMin = lngMore ? arguments[0] : 1; iMax = arguments[lngMore ? 1 : 0]; dI = lngMore > 1 ? arguments[2] : 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 ?'
);</lang>
Output:
2, 4, 6, 8, who do we appreciate ?
jq
To generate the stream: 2,4,6,8:<lang jq># 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)</lang> Example: <lang jq>reduce range(2;9;2) as $i
(""; . + "\($i), ") + "whom do we appreciate?"</lang>
Julia
<lang julia>for i in 2:2:8
print(i, ", ")
end println("whom do we appreciate?")</lang>
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
<lang lang5>: <range> over iota swap * rot + tuck swap <= select ; : tuck swap over ;
- >>say.(*) . ;
1 10 2 <range> >>say.</lang>
Lasso
<lang Lasso>loop(-to=100, -from=1, -by=2) => {^
loop_count '\r' // for formatting
^}</lang>
Liberty BASIC
<lang lb> for i = 2 to 8 step 2
print i; ", ";
next i print "who do we appreciate?" end </lang>
Lisaac
<lang Lisaac>1.to 9 by 2 do { i : INTEGER;
i.print; '\n'.print;
};</lang>
LiveCode
<lang LiveCode>repeat with n = 0 to 10 step 2
put n after loopn if n is not 10 then put comma after loopn
end repeat put loopn</lang> Output<lang LiveCode>0,2,4,6,8,10</lang>
Logo
<lang logo>for [i 2 8 2] [type :i type "|, |] print [who do we appreciate?]</lang>
Lua
<lang lua> for i=2,9,2 do
print(i)
end </lang>
- Output:
2 4 6 8
M4
<lang 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 ')</lang>
- Output:
1 4
Maple
<lang Maple>for i from 2 to 8 by 2 do
i;
end do;</lang>
- Output:
2 4 6 8
Mathematica
<lang Mathematica>Do[
Print@i, {i, 1, 20, 4}]</lang>
- Output:
1 5 9 13 17
MATLAB / Octave
<lang Matlab> for k = 0:10:100,
printf('%d\n',k) end; </lang>
A vectorized version of the code is
<lang Matlab> printf('%d\n',0:10:100); </lang>
Maxima
<lang maxima>for i: 1 step 2 thru 10 do print(i); /* 1
3 5 7 */</lang>
MAXScript
<lang MAXScript>for i = 0 to 10 by 2 do format "%\n" i</lang> Output: <lang MAXScript> 0 2 4 6 8 10 OK </lang>
МК-61/52
<lang>1 П0 ИП0 3 + П0 1 0 - x#0 02 С/П</lang>
In this example, the step is 3, the lowest value is 1 and the upper limit is 10.
Modula-2
<lang modula2>MODULE ForBy;
IMPORT InOut;
VAR i: INTEGER;
BEGIN
FOR i := 0 TO 100 BY 2 DO InOut.WriteInt(i, 3); InOut.WriteLn END
END ForBy.</lang>
Modula-3
<lang modula3>FOR i := 1 TO 100 BY 2 DO
IO.Put(Fmt.Int(i) & " ");
END;</lang>
MUMPS
<lang MUMPS>FOR I=65:3:122 DO
.WRITE $CHAR(I)," "</lang>
- Output:
A D G J M P S V Y \ _ b e h k n q t w z
NewLISP
<lang NewLISP>(for (i 0 10 2)
(println i))</lang>
Nim
<lang nim>for x in countdown(10,0,3): echo(x)</lang>
- Output:
10 7 4 1
Nemerle
<lang Nemerle>for (i = 2; i <= 8; i +=2)</lang> <lang Nemerle>foreach (i in [2, 4 .. 8])</lang>
NetRexx
<lang 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</lang>
- 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<(pre> =={{header|Oberon-2}}== Works with oo2c Version 2 <lang oberon2> 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 END END LoopForStep. </lang> Output: <pre> 0 3 6 9 10 7 4 1
Objeck
<lang objeck> for(i := 0; i < 10; i += 2;) {
i->PrintLine();
}; </lang>
OCaml
<lang 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 = ()</lang>
Octave
<lang octave>for i = 1:2:10
disp(i)
endfor</lang>
Oforth
<lang Oforth> 1 100 2 step: i [ i println ]</lang>
Openscad
<lang openscad>/* Loop from 3 to 9 in steps of 2 */
for ( l = [3:2:9] ) {
echo (l);
} echo ("on a double white line.");</lang>
Oz
<lang oz>for I in 2..8;2 do
{System.show I}
end {System.show done} </lang>
PARI/GP
<lang parigp>forstep(n=1,10,2,print(n))</lang>
The forstep
construct is actually more powerful.
For example, to print numbers with last digit relatively prime to 10:
<lang parigp>forstep(n=1,100,[2,4,2,2],print(n))</lang>
Panda
Panda doesn't nativly have a number generator with steps, so let's add it. <lang panda>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)</lang>
Pascal
See Delphi
Perl
<lang perl>for($i=2; $i <= 8; $i += 2) {
print "$i, ";
} print "who do we appreciate?\n";</lang>
Perl 6
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.)
<lang perl6>for 2, 4 ... 8 {
print "$_, ";
}
say 'whom do we appreciate?';</lang>
Phix
<lang Phix>for i=2 to 8 by 2 do
printf(1,"%d, ",i)
end for printf(1,"who do we appreciate?\n")</lang>
PHP
<lang php><?php foreach (range(2, 8, 2) as $i)
echo "$i, ";
echo "who do we appreciate?\n"; ?></lang>
- Output:
2, 4, 6, 8, who do we appreciate?
PicoLisp
<lang PicoLisp>(for (N 1 (> 10 N) (+ N 2))
(printsp N) )</lang>
Pike
<lang pike>int main() {
for(int i = 2; i <= 16; i=i+2) { write(i + "\n"); }
}</lang>
PL/I
<lang PL/I> declare (n, i) fixed binary;
get list (n); do i = 1 to n by 4;
put skip list (i);
end; </lang>
PowerShell
<lang powershell>for ($i = 0; $i -lt 10; $i += 2) {
$i
}</lang>
PureBasic
<lang PureBasic>For i=-15 To 25 Step 5
Debug i
Next i</lang>
Python
<lang python>for i in xrange(2, 9, 2):
print "%d," % i,
print "who do we appreciate?"</lang>
<lang python>for i in range(2, 9, 2):
print("%d, " % i, end="")
print("who do we appreciate?")</lang>
- Output:
2, 4, 6, 8, who do we appreciate?
R
<lang R>for(a in seq(2,8,2)) {
cat(a, ", ")
} cat("who do we appreciate?\n")</lang>
Racket
<lang racket>
- lang racket
(for ([i (in-range 2 9 2)])
(printf "~a, " i))
(printf "who do we appreciate?~n") </lang>
Raven
List of numbers: <lang Raven>[ 2 4 6 8 ] each "%d, " print "who do we appreciate?\n" print</lang>
Range: <lang Raven>2 10 2 range each "%d, " print "who do we appreciate?\n" print</lang>
- Output:
2, 4, 6, 8, who do we appreciate?
REBOL
<lang REBOL>for i 2 8 2 [ prin rejoin [i ", "]] print "who do we appreciate?"</lang>
- Output:
2, 4, 6, 8, who do we appreciate?
REXX
version 1
<lang rexx> do x=1 to 10 by 1.5
say x end</lang>
- Output:
1 2.5 4.0 5.5 7.0 8.5 10.0
version 2
<lang rexx> do thing=1 by 3/2 to 10
say thing end</lang>
output is the same as above.
Ring
we use step keyword to define step length in this example we print Even numbers between 0 and 10 <lang ring> for i = 0 to 10 step 2 see i + nl next </lang>
- Output:
2 4 6 8 10
we can use step with double values as well: <lang ring> for i = 0 to 10 step 0.5 see i + nl next </lang>
- 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
<lang ruby>2.step(8,2) {|n| print "#{n}, "} puts "who do we appreciate?"</lang> or: <lang ruby>(2..8).step(2) {|n| print "#{n}, "} puts "who do we appreciate?"</lang> or: <lang ruby>for n in (2..8).step(2)
print "#{n}, "
end puts "who do we appreciate?"</lang>
- Output:
2, 4, 6, 8, who do we appreciate?
Run BASIC
<lang runbasic>for i = 2 to 8 step 2
print i; ", ";
next i print "who do we appreciate?"</lang>
- Output:
2, 4, 6, 8, who do we appreciate?
Rust
<lang rust>fn main() {
let mut i = 2; while i <= 8 { print!("{}, ", i); i += 2; } println!("who do we appreciate?!");
}</lang>
Prettier, but currently feature gated version (Rust 1.0)
Does not work in stable Rust <lang rust>#![feature(step_by)]
fn main() {
for i in (2..8+1).step_by(2) { print!("{}", i); } println!("who do we appreciate?!");
}</lang> Additionally, there is a crate on crates.io called cfor which allows for the use of a C-like for loop. <lang rust> #[macro_use] extern crate cfor;
fn main() {
cfor!(let mut i = 2; i <= 8; i+=2; { println!("{}", i); }); println!("Who do we appreciate?");
}</lang>
Salmon
<lang Salmon>for (x; 2; x <= 8; 2)
print(x, ", ");;
print("who do we appreciate?\n");</lang>
SAS
<lang sas>data _null_; do i=1 to 10 by 2; put i; end; run;</lang>
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:
<lang sather> i :INT;
loop i := for!(1, 50, 2); -- OR -- i := 1.stepto!(50, 2); #OUT + i + "\n"; end;</lang>
(Print all odd numbers from 1 to 50)
Scala
<lang scala> for (i <- 2 to 8 by 2) {
println(i)
} </lang>
Alternately: <lang scala> (2 to 8 by 2) foreach println</lang>
Scheme
The built-in for-like form in Scheme is the do form:
<lang scheme>(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))</lang>
Some people prefer to use the recursive-style and more flexible _named let_ form:
<lang scheme>(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</lang>
You can add to the language by wrapping the loop in a function:
<lang scheme>(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)))</lang>
... or in a macro, which allows for making the (lambda)
implicit:
<lang scheme>(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))</lang>
- Output:
2 4 6 8
Scilab
<lang>for i=1:2:10
printf("%d\n",i)
end</lang>
- Output:
1 3 5 7 8
Seed7
<lang 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;</lang>
Sidef
for(;;) loop: <lang ruby>for (var i = 2; i <= 8; i += 2) {
say i
}</lang>
for-in loop: <lang ruby>for i in (2 ..^ (8, 2)) {
say i
}</lang>
.each method: <lang ruby>2.to(8).by(2).each { |i|
say i
}</lang>
Simula
<lang simula> BEGIN
INTEGER i; FOR i:=5 UNTIL 25 STEP 5 DO OutInt(i,5) END</lang>
Slate
<lang slate>2 to: 8 by: 2 do: [| :i | Console ; i printString ; ', ']. inform: 'enough with the cheering already!'.</lang>
Smalltalk
<lang smalltalk>2 to: 8 by: 2 do: [ :i |
Transcript show: i; show ', '
]. Transcript showCr: 'enough with the cheering already!'</lang>
Swift
This prints all odd digits: <lang swift>for i in 1.stride(to: 10, by: 2) {
print(i)
}</lang> Alternately (removed in Swift 3): <lang swift>for var i = 1; i < 10; i += 2 {
print(i)
}</lang>
Tcl
<lang tcl>for {set i 2} {$i <= 8} {incr i 2} {
puts -nonewline "$i, "
} puts "enough with the cheering already!"</lang>
TI-83 BASIC
Prints numbers from 0 to 100 stepping by 5. <lang ti83b>:For(I,0,100,5
- Disp I
- End</lang>
TI-89 BASIC
<lang ti89b>Local i For i, 0, 100, 5
Disp i
EndFor</lang>
TorqueScript
<lang TorqueScript>for(%i = 0; %i < 201; %i += 2) { echo(%i); }</lang>
TUSCRIPT
<lang tuscript> $$ MODE TUSCRIPT LOOP i=2,9,2 PRINT i ENDLOOP </lang>
- Output:
2 4 6 8
UNIX Shell
All these loops iterate 2, 4, 6, 8.
Bourne Shell
<lang bash>x=2 while test $x -le 8; do echo $x x=`expr $x + 2` || exit $? done</lang>
<lang bash>for x in `jot - 2 8 2`; do echo $x; done</lang>
Korn Shell
<lang bash>x=2 while $x -le 8; do echo $x ((x=x+2)) done</lang>
<lang bash>x=2 while ((x<=8)); do echo $x ((x+=2)) done</lang>
Bourne Again Shell
<lang bash>for (( x=2; $x<=8; x=$x+2 )); do
printf "%d, " $x
done</lang>
Bash v4.0+ has inbuilt support for setting up a step value <lang bash>for x in {2..8..2} do
echo $x
done</lang>
C Shell
<lang csh>foreach x (`jot - 2 8 2`) echo $x end</lang>
Ursa
<lang ursa>decl int i for (set i 2) (< i 9) (set i (int (+ i 2))) out i ", " console end for out "who do we appreciate?" endl console</lang>
Vedit macro language
This prints all odd digits in range 1 to 9: <lang vedit>for (#1 = 1; #1 < 10; #1 += 2) {
Num_Type(#1)
}</lang>
VBA
<lang vb>Sub MyLoop()
For i = 2 To 8 Step 2 Debug.Print i; Next i Debug.Print
End Sub</lang>
- Output:
2 4 6 8
VBScript
<lang vb> buffer="" For i = 2 To 8 Step 2
buffer=buffer & i & " " Next wscript.echo buffer</lang>
- Output:
2 4 6 8
Vim Script
<lang vim>for i in range(2, 10, 2)
echo i
endfor</lang>
- Output:
2 4 6 8 10
Visual Basic
<lang vb>Sub MyLoop()
For i = 2 To 8 Step 2 Debug.Print i; Next i Debug.Print
End Sub</lang>
- Output:
2 4 6 8
Visual Basic .NET
<lang vbnet>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 Sub
End Class</lang>
- Output:
2 4 6 8
Vorpal
<lang vorpal>for(i = 2, i <= 8, i = i + 2){
i.print()
}</lang>
Wart
<lang wart>for i 2 (i <= 8) (i <- i+2)
prn i</lang>
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:
<lang XPL0>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?"); ]</lang>
- Output:
2, 4, 6, 8, who do we appreciate?
zkl
<lang zkl>foreach n in ([1..10,4]) {println(n)} [1..10,3].pump(Console.println)</lang>
- Output:
1 5 9 1 4 7 10
A few others: <lang zkl>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})</lang>
ZX Spectrum Basic
<lang basic>10 FOR l = 2 TO 8 STEP 2 20 PRINT l; ", "; 30 NEXT l 40 PRINT "Who do we appreciate?"</lang>
- Programming Tasks
- Iteration
- Simple
- 360 Assembly
- Ada
- Aime
- ALGOL 60
- ALGOL 68
- ALGOL W
- AppleScript
- AutoHotkey
- AWK
- Axe
- BASIC
- Applesoft BASIC
- Basic
- Batch File
- BBC BASIC
- Bc
- Befunge
- C
- ChucK
- C++
- C sharp
- Ceylon
- Clojure
- COBOL
- ColdFusion
- Common Lisp
- Chapel
- D
- Dao
- Delphi
- DWScript
- E
- EchoLisp
- Ela
- Elena
- Elixir
- ERRE
- Erlang
- Euphoria
- Factor
- FALSE
- Fantom
- FBSL
- Forth
- Fortran
- F Sharp
- GAP
- GML
- Go
- Groovy
- Haskell
- HicEst
- Icon
- Unicon
- Io
- J
- Java
- JavaScript
- Jq
- Julia
- LabVIEW
- Lang5
- Lasso
- Liberty BASIC
- Lisaac
- LiveCode
- Logo
- Lua
- M4
- Maple
- Mathematica
- MATLAB
- Octave
- Maxima
- MAXScript
- МК-61/52
- Modula-2
- Modula-3
- MUMPS
- NewLISP
- Nim
- Nemerle
- NetRexx
- Objeck
- OCaml
- Oforth
- Openscad
- Oz
- PARI/GP
- Panda
- Pascal
- Perl
- Perl 6
- Phix
- PHP
- PicoLisp
- Pike
- PL/I
- PowerShell
- PureBasic
- Python
- R
- Racket
- Raven
- REBOL
- REXX
- Ring
- Ruby
- Run BASIC
- Rust
- Salmon
- SAS
- Sather
- Scala
- Scheme
- Scilab
- Seed7
- Sidef
- Simula
- Slate
- Smalltalk
- Swift
- Tcl
- TI-83 BASIC
- TI-89 BASIC
- TorqueScript
- TUSCRIPT
- UNIX Shell
- Bourne Shell
- Jot
- Korn Shell
- C Shell
- Ursa
- Vedit macro language
- VBA
- VBScript
- Vim Script
- Visual Basic
- Visual Basic .NET
- Vorpal
- Wart
- XPL0
- Zkl
- ZX Spectrum Basic
- GUISS/Omit