Loops/For with a specified step: Difference between revisions

[[Category:Simple]]

 

 

 

*   [[Loops/Wrong ranges]]

<br><br>

 

=={{header|360 Assembly}}==

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

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

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

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

 

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

INTEGER I;

FOR I := 1 STEP 3 UNTIL 19 DO

WRITE( I );

 

 

log i

 

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

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

 

 

 

=={{header|Arturo}}==

{{out}}

<pre>0

 

=={{header|AutoHotkey}}==

iterations := 5

step := 10

MsgBox, % A_Index

}

 

=={{header|AWK}}==

 

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

print i

}

print "Ain't never too late!"

 

=={{header|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:

Disp I▶Dec,i

I++

 

 

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

110 PRINT I

 

 

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

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

echo %%A

{{Out}}

<pre>>Sample.BAT

 

></pre>

 

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

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

}

print("who do we appreciate?");

 

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

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

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

 

{$APPTYPE CONSOLE}

var

i: Integer;

Inc(i, 2);

end;

{{out}}

<pre>2

 

=={{header|Dragon}}==

}

 

=={{header|DWScript}}==

 

for i := 2 to 8 step 2 do

 

{{out}}

6

8</pre>

 

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

{

{

}

 

=={{header|Elixir}}==

def for_step(n, step) do

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

end

 

 

{{out}}

</pre>

or

 

{{out}}

<pre>

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

 

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

If it is given an <code>integer</code>, or an <code>atom</code>

(Any number that is not an <code>integer</code>), it will print those out as-is.

 

=={{header|Factor}}==

Prints odd digits.

 

=={{header|FALSE}}==

 

=={{header|Fantom}}==

 

class Main

{

}

}

 

=={{header|FBSL}}==

 

DIM n AS INTEGER

PRINT ", who will we obliterate?"

PAUSE

 

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

 

s(0) = "Somewhere"

print s(i);

next

 

 

 

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

}

 

{{out}}

 

=={{header|Haskell}}==

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

 

=={{header|hexiscript}}==

println i

 

=={{header|HicEst}}==

WRITE() i

 

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

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.

If in doubt parenthesize.

 

 

=={{header|Io}}==

write(i,", ")

)

 

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

 

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

 

 

 

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

{{VI solution|LabVIEW_Loops_For_with_a_specified_step.png}}

 

=={{header|Lang5}}==

: >>say.(*) . ;

 

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

8

</pre>

=={{header|M2000 Interpreter}}==

===A for loop===

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

{{out}}

<pre>

 

=={{header|M4}}==

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

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

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

')

 

{{out}}

 

=={{header|Maple}}==

i;

{{out}}

<pre>

</pre>

 

{{out}}

<pre>1

9

13

 

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

 

printf('%d\n',k)

 

A vectorized version of the code is

 

 

=={{header|Maxima}}==

/* 1

3

5

=={{header|MAXScript}}==

Output:

0

2

10

OK

 

 

=={{header|MiniScript}}==

print i

 

{{out}}

 

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

<pre>A D G J M P S V Y \ _ b e h k n q t w z</pre>

 

=={{header|Nemerle}}==

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols nobinary

 

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

end i_

{{out}}

<pre>D:\>java lst

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

 

 

 

=={{header|Oberon-2}}==

Works with oo2c Version 2

MODULE LoopForStep;

IMPORT

END

END LoopForStep.

Output:

<pre>

1

</pre>

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

 

 

=={{header|Openscad}}==

 

 

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

echo (l);

}

 

=={{header|Oz}}==

{System.show I}

end

{System.show done}

 

=={{header|Panda}}==

t=to.minus(from).divide(step)

0..t.times(step).plus(from)

/test it for(1 6 2) -> 1 3 5

 

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

print "$i, ";

}

 

 

 

 

 

=={{header|PHP}}==

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

echo "$i, ";

echo "who do we appreciate?\n";

{{out}}

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

C :i = 1

*Loop

C :i = i + 2

J ( i < 10 ) :*Loop

 

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

declare (n, i) fixed binary;

 

put skip list (i);

end;

 

=={{header|PowerShell}}==

$i

 

=={{header|Prolog}}==

If you need a stepping iterator, write one:

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.

<pre>?- example.

0 2 4 6 8 10

true.</pre>

Adding the following two rules lets you go backwards too:

 

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

}

 

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

 

 

=={{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 ", "]]

 

{{out}}

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

 

=={{header|REXX}}==

===version 1===

say x

{{out}}

<pre>

 

===version 2===

say thing

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

<br><br>

 

===version 3===

Say v

End

{{output}}

<pre>1

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

 

{{out}}

 

we can use step with double values as well:

for i = 0 to 10 step 0.5 see i + nl next

{{out}}

<pre>

</pre>

 

=={{header|Ruby}}==

or:

or:

print "#{n}, "

end

{{out}}

<pre>

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

</pre>

 

=={{header|Rust}}==

 

For Rust 1.28 and later:

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:

let mut i = 2;

while i <= 8 {

}

println!("who do we appreciate?!");

 

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

 

Alternatively:

 

=={{header|Scheme}}==

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

 

((>= i 9)) ; exit condition

(display i) ; body

 

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

 

(cond ((< i 9)

(display i)

(newline)

 

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

 

(let loop ((i start))

(cond ((< i end)

(lambda (i)

(display i)

 

... or in a macro, which allows for making the <code>(lambda)</code> implicit:

 

(syntax-rules ()

((for-loop index start end step body ...)

(for-loop i 2 9 2

(display i)

 

{{out}}

=={{header|Scilab}}==

{{works with|Scilab|5.5.1}}

printf("%d\n",i)

{{out}}

<pre>1

 

=={{header|Seed7}}==

 

const proc: main is func

var integer: number is 0;

begin

writeln(number);

end for;

 

=={{header|Sidef}}==

 

'''for(;;)''' loop:

say i

 

'''for-in''' loop:

say i

 

'''.each''' method:

say i

 

=={{header|Simula}}==

integer i;

for i:=5 step 5 until 25 do outint(i, 5)

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

Transcript show: i; show ', '

].

 

=={{header|Spin}}==

{{works with|HomeSpun}}

{{works with|OpenSpin}}

_clkmode = xtal1 + pll16x

_clkfreq = 80_000_000

waitcnt(_clkfreq + cnt)

ser.stop

{{out}}

<pre>

 

=={{header|SPL}}==

#.output(n)

 

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

00101000000001100000000000000000 1. c to 20

00101000000000100000000000000000 2. -20 to c

10100000000000000000000000000000 22. 5

00000000000000000000000000000000 23. 0

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

 

=={{header|Stata}}==

display "`i'"

}

5

7

=={{header|Swift}}==

This prints all odd digits:

print(i)

Alternately (removed in Swift 3):

print(i)

 

=={{header|Tcl}}==

puts -nonewline "$i, "

}

 

=={{header|TorqueScript}}==

 

{

echo(%i);

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

LOOP i=2,9,2

PRINT i

ENDLOOP

{{out}}

<pre>

==={{header|Bourne Shell}}===

{{works with|Bourne Shell}}

while test $x -le 8; do

{{works with|Bourne Shell}}

{{libheader|jot}}

 

 

===Bourne Again Shell===

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

{{trans|Python}}

for (set i 2) (< i 9) (set i (int (+ i 2)))

out i ", " console

end for

 

=={{header|Vala}}==

 

=={{header|VAX Assembly}}==

50 D4 0002 2 clrf r0 ;init to 0.0

0004 3 loop:

000B 6

04 000B 7 ret

 

=={{header|VBA}}==

For i = 2 To 8 Step 2

Debug.Print i;

Next i

Debug.Print

{{out}}

<pre>

 

=={{header|VBScript}}==

For i = 2 To 8 Step 2

buffer = buffer & i & " "

Next

{{out}}

<pre>2 4 6 8</pre>

 

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

echo i

 

{{Out}}

10</pre>

 

 

{{out}}

<pre>

</pre>

 

{{out}}

<pre>

</pre>

 

=={{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?");

 

{{out}}

 

=={{header|zkl}}==

{{out}}

<pre>

</pre>

A few others: