Loops/For with a specified step: Difference between revisions

{{task|Iteration}}

=={{header|Ada}}==

 

use Loopers;

 

end Loopers;

 

 

 

=={{header|Aime}}==

 

i = 0;

}

 

 

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

'''fi'''

'''end'''

 

There are several unusual aspects of the construct:

'''od'''

 

* '''until'''^(C) - for late loop termination.

* '''foreach'''^(S) - for working on arrays in [[wp:Parallel computing|parallel]].

 

=={{header|AutoHotkey}}==

iterations := 5

step := 10

MsgBox, % A_Index

}

 

=={{header|AWK}}==

 

}

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

print i; ", ";

next i

 

PRINT n

<pre>

2

8

</pre>

 

=={{header|bc}}==

i

 

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

(println i)

(when (< i 10)

 

(doseq [i (range 0 12 2)]

 

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

 

<pre>

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

</pre>

 

 

{{out}}

<pre>

</pre>

 

=={{header|D}}==

 

void main() {

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

writeln(i);

{{out}}

<pre>1

 

=={{header|Dao}}==

# max value: 9

# step: 2

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

var

i: Integer;

Inc(i, 2);

end;

<pre>2

4

6

8</pre>

 

=={{header|DWScript}}==

 

for i := 2 to 8 step 2 do

 

<pre>2

4

6

8</pre>

 

=={{header|E}}==

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, `)

}

 

 

 

 

 

 

<pre>0

2

8

10</pre>

 

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

<pre>

* * ok

</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")

 

 

=={{header|Factor}}==

Prints odd digits.

 

=={{header|FALSE}}==

 

=={{header|Fantom}}==

 

class Main

{

}

}

 

=={{header|FBSL}}==

 

DIM n AS INTEGER

PRINT ", who will we obliterate?"

PAUSE

 

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

}

 

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

Go Team!

 

=={{header|Haskell}}==

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

 

=={{header|HicEst}}==

WRITE() i

 

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

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

 

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 writes( (TO_BY_EXPR) | "\n", " " ) # if you want to see how any of these work

 

=={{header|J}}==

 

 

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

 

=={{header|Java}}==

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

}

 

=={{header|JavaScript}}==

i;

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

}

output += 'who do we appreciate?';

 

=={{header|jq}}==

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

 

'''Example''':

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

 

=={{header|Julia}}==

print(i, ", ")

end

 

=={{header|LabVIEW}}==

{{VI solution|LabVIEW_Loops_For_with_a_specified_step.png}}

 

=={{header|Lang5}}==

: >>say.(*) . ;

 

 

=={{header|Lasso}}==

loop_count

'\r' // for formatting

 

 

=={{header|Lisaac}}==

i.print;

'\n'.print;

 

=={{header|Logo}}==

 

=={{header|Lua}}==

for i=2,9,2 do

print(i)

end

 

<pre>

2

6

8

</pre>

 

=={{header|M4}}==

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

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

 

for(`x',`1',`5',`3',`x

 

<pre>

1

 

=={{header|Maple}}==

i;

<pre>

</pre>

 

<pre>1

5

9

13

 

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

 

printf('%d\n',k)

 

A vectorized version of the code is

 

 

=={{header|Maxima}}==

/* 1

3

5

 

=={{header|МК-61/52}}==

 

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

 

=={{header|Modula-2}}==

IMPORT InOut;

 

InOut.WriteLn

END

 

=={{header|Modula-3}}==

IO.Put(Fmt.Int(i) & " ");

 

=={{header|MUMPS}}==

{{out}}

 

=={{header|Nemerle}}==

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols nobinary

 

say i_.format(3, 1) || '\0'

end i_

 

=={{header|Objeck}}==

for(i := 0; i < 10; i += 2;) {

i->PrintLine();

};

 

=={{header|OCaml}}==

let rec aux i =

if i <= b then begin

6

8

 

=={{header|Octave}}==

disp(i)

 

=={{header|Openscad}}==

 

 

for ( l = [3:2:9] ) {

echo (l);

}

 

=={{header|Oz}}==

{System.show I}

end

{System.show done}

 

=={{header|PARI/GP}}==

 

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

print "$i, ";

}

 

 

 

 

=={{header|PHP}}==

foreach (range(2, 8, 2) as $i)

echo "$i, ";

echo "who do we appreciate?\n";

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

 

=={{header|PicoLisp}}==

 

=={{header|Pike}}==

for(int i = 2; i <= 16; i=i+2) {

write(i + "\n");

}

 

=={{header|PL/I}}==

declare (n, i) fixed binary;

 

put skip list (i);

end;

 

=={{header|PowerShell}}==

$i

 

 

=={{header|Python}}==

{{works with|Python|2.x}}

print "%d," % i,

 

{{works with|Python|3.x}}

print("%d, " % i, end="")

 

{{out}}

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

 

=={{header|R}}==

cat(a, ", ")

}

 

=={{header|Racket}}==

 

#lang racket

 

(printf "~a, " i))

(printf "who do we appreciate?~n")

 

=={{header|Raven}}==

List of numbers:

 

Range:

{{out}}

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

 

=={{header|REBOL}}==

prin rejoin [i ", "]]

 

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

 

=={{header|REXX}}==

===version 1===

say x

<pre>

1

 

===version 2===

say thing

'''output''' is the same as above.

<br><br>

 

=={{header|Ruby}}==

or:

or:

print "#{n}, "

end

<pre>

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

</pre>

 

=={{header|Rust}}==

 

}

 

=={{header|Salmon}}==

print(x, ", ");;

 

=={{header|SAS}}==

do i=1 to 10 by 2;

put i;

end;

 

=={{header|Sather}}==

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

loop

i := for!(1, 50, 2);

-- i := 1.stepto!(50, 2);

#OUT + i + "\n";

 

(Print all odd numbers from 1 to 50)

 

=={{header|Scala}}==

 

 

=={{header|Scheme}}==

(let loop ((i start))

(cond ((< i end)

(lambda (i)

(display i)

 

4

6

 

=={{header|Seed7}}==

 

const proc: main is func

var integer: number is 0;

begin

writeln(number);

end for;

 

=={{header|Sidef}}==

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

Transcript show: i; show ', '

].

 

=={{header|Swift}}==

This prints all odd digits:

 

=={{header|Tcl}}==

puts -nonewline "$i, "

}

 

=={{header|TorqueScript}}==

 

{

echo(%i);

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

LOOP i=2,9,2

PRINT i

ENDLOOP

<pre>

2

=={{header|UNIX Shell}}==

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

{{works with|Bourne Shell}}

while test $x -le 8; do

{{works with|Bourne Shell}}

{{libheader|jot}}

 

{{works with|Bourne Again SHell|3}}

printf "%d, " $x

 

{{works with|Bourne Again SHell|4}}

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

do

echo $x

==={{header|C Shell}}===

{{libheader|jot}}

echo $x

 

=={{header|Vedit macro language}}==

This prints all odd digits in range 1 to 9:

Num_Type(#1)

 

=={{header|Vim Script}}==

echo i

 

{{Out}}

8

10</pre>

 

=={{header|Vorpal}}==

i.print()

 

=={{header|Wart}}==

 

=={{header|XPL0}}==

thus a step by 2 can be implemented like this:

 

int I;

[for I:= 2 to 8 do

];

Text(0, "who do we appreciate?");

 

<pre>

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

 

=={{header|zkl}}==

{{out}}

<pre>

</pre>

A few others: