Loops/Continue: Difference between revisions

{{trans|Python}}

I i % 5 == 0

print(i)

L.continue

{{out}}

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

LOOPCONT CSECT

USING LOOPCONT,R12

XDEC DS CL16

YREGS

{{out}}

<pre> 1, 2, 3, 4, 5

forgo the null statement.

use Ada.Text_IO;

<<Continue>> --Ada 2012 no longer requires a statement after the label

end loop;

'''N.''' This is a more true-to-Ada strategy for 'continue' comprising of an outer iteration loop and an inner labeled single-pass loop. This is a safer strategy than using goto which could be problematic when dealing with complex nested loops.

use Ada.Text_IO;

end loop Print_Element;

end loop Print_All;

=={{header|Agena}}==

Agena doesn't have a continue statement, conditional statements can be used instead.

write( i );

if i % 5 = 0

else write( ", " )

fi

=={{header|Aikido}}==

print (i)

if ((i % 5) == 0) {

}

print (", ")

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

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

[[ALGOL 68]] has no continue reserved word, nor does it need one. The continue reserved word is only syntactic sugar for operations that can be achieved without it as in the following example:

print ((i,

IF i MOD 5 = 0 THEN

FI

))

{{Out}}

<pre>

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

Algol W doesn't have a continue statement - conditional statements can be used instead.

i_w := 1; s_w := 0; % set output format %

for i := 1 until 10 do begin

else writeon( ", " )

end for_i

=={{header|AppleScript}}==

set table to {return}

repeat with i from 1 to 10

end repeat

return table as string

{{out}}

<pre>

=={{header|Arturo}}==

prints i

if 0 = i%5 [

]

prints ", "

{{out}}

=={{header|Asymptote}}==

Asymptote's control structures are similar to those in C/C++

write(i, suffix=none);

if(i % 5 == 0) {

write(", ", suffix=none);

}

=={{header|AutoHotkey}}==

Delimiter := (A_Index = 5) || (A_Index = 10) ? "`n":", "

Index .= A_Index . Delimiter

}

=={{header|AWK}}==

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

printf("%d", i)

printf(", ")

}

=={{header|BASIC}}==

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

20 PRINT I;

30 IF I - INT (I / 5) * 5 = 0 THEN PRINT : GOTO 50"CONTINUE

40 PRINT ", ";

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

print string(i);

if i mod 5 = 0 then

next

print

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

BBC BASIC doesn't have a 'continue' statement so the remainder of the loop must be made conditional.

PRINT ; i% ;

IF i% MOD 5 = 0 PRINT ELSE PRINT ", ";

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

Commodore BASIC also doesn't have a 'continue' statement. In this example, a GOTO statement is used to simulate 'CONTINUE'. However, Commodore BASIC doesn't have a modulo (remainder) operator, so value of I/5 is check against INT(I/5). If they are the same, the remainder is zero.

20 PRINT I;

30 IF INT(I/5) = I/5 THEN PRINT : GOTO 50

40 PRINT ", ";

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

For i As Integer = 1 To 10

Print Str(i);

Print

{{out}}

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

110 PRINT STR$(I);

120 IF MOD(I,5)=0 THEN

150 PRINT ", ";

160 END IF

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

for i =1 to 10

if i mod 5 <>0 then print i; ", "; else print i

next i

end

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

For i.i = 1 To 10

Next

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

For i = 1 To 10

Print LTrim$(Str$(i));

End If

Print ", ";

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

{{works with|QBasic}}

if i mod 5 <> 0 then print i;", "; else print i

==={{header|Sinclair ZX81 BASIC}}===

This probably isn't the most idiomatic way to produce the specified output—but it does illustrate ZX81 BASIC's equivalent of <code>if <condition> continue</code>, which is <code>IF <condition> THEN NEXT <loop-control variable></code>.

20 PRINT I;

30 IF I/5=INT (I/5) THEN PRINT

40 IF I/5=INT (I/5) THEN NEXT I

50 PRINT ", ";

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

Prgm

""→s

s&", "→s

EndFor

Ti-89 lacks support for multi-argument display command or controlling the print position so that one can print several data on the same line. The display command (Disp) only accepts one argument and prints it on a single line (causing a line a feed at the end, so that the next Disp command will print in the next line). The solution is appending data to a string (s), using the concatenator operator (&), by converting numbers to strings, and then printing the string at the end of the line.

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

PRINT STR$(i);

IF REMAINDER(i, 5) = 0 THEN

NEXT i

PRINT

==={{header|VB-DOS, PDS}}===

OPTION EXPLICIT

IF (i MOD 5) THEN PRINT ","; ELSE PRINT

NEXT i

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

Console.Write(i)

If i Mod 5 = 0 Then

Console.Write(", ")

End If

=={{header|bc}}==

{{works with|OpenBSD bc}}

print i

if (i % 5) {

print "\n"

}

=={{header|Befunge}}==

Befunge outputs numbers with a space after them, so the formatting is slightly off in this version.

1>:56+\`#v_@

+v %5:.:<

>" ,",,v

^ <

This version outputs a 'backspace' ASCII character to try to correct the format, but it may or may not work depending on if the character is accounted for by the output

1>:56+\`#v_@

+v5:,8.:<

>" ,",v

^ ,<

=={{header|Bracmat}}==

Bracmat has no continue statement.

& whl

' ( 1+!i:~>10:?i

)

)

=={{header|C}}==

{{trans|C++}}

printf("%d", i);

if(i % 5 == 0){

}

printf(", ");

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

{{trans|Java}}

class Program {

}

}

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

{{trans|Java}}

cout << i;

if(i % 5 == 0){

}

cout << ", ";

=={{header|Chapel}}==

write(i);

if i % 5 == 0 then {

}

write(", ");

=={{header|Clipper}}==

Works as is with Harbour 3.0.0 (Rev. 16951)

?? i

IF i % 5 == 0

ENDIF

?? ", "

=={{header|Clojure}}==

Clojure doesn't have a continue keyword. It has a recur keyword, although I prefer to work with ranges in this case.

(print n)

(if (zero? (rem n 5))

(println)

To address the task, however, here's an example loop/recur:

(when-let [x (first xs)]

(print x)

(println)

(print ", "))

=={{header|COBOL}}==

PROGRAM-ID. loop-continue.

GOBACK

Note: COBOL does have a <code>CONTINUE</code> verb, but this is a no-operation statement used in <code>IF</code> and <code>EVALUATE</code> statements.

=={{header|ColdFusion}}==

Remove the leading space from the line break tag.

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

{

writeOutput( "," );

}

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

The second uses the implicit <code>tagbody</code> and <code>go</code>.

The third is a do loop with conditionals outside of the output functions.

((> i 10))

(format t "~a~:[, ~;~%~]" i (zerop (mod i 5))))

(if (zerop (mod i 5))

(terpri)

These use the <code>loop</code> iteration form, which does not contain an implicit tagbody (though one could be explicitly included).

the second uses <code>block</code>/<code>return-from</code> to obtain the effect of skipping the rest of the code in the <code>block</code> which makes up the entire loop body.

do (write i)

if (zerop (mod i 5))

(terpri)

(return-from continue))

=={{header|D}}==

void main() {

write(", ");

}

{{out}}

<pre>1, 2, 3, 4, 5

===Shorter version===

import std.stdio;

foreach(i; 1..11) i % 5 ? writef("%s, ", i) : writeln(i);

}

=={{header|dc}}==

{{works with|OpenBSD dc}}

[2Q]sA # A = code to break loop

[[, ]P 1J]sB # B = code to print comma, continue loop

li 1 + si # i += 1

li 10!<C # continue loop if 10 >= i

This program uses <tt>J</tt> and <tt>M</tt> to force the next iteration of a loop.

=={{header|Delphi}}==

var

i: integer;

write(', ');

end;

{{Out}}

=={{header|DWScript}}==

for i := 1 to 10 do begin

end;

Print(', ');

=={{header|Dyalect}}==

{{trans|Swift}}

print(i, terminator: "")

if i % 5 == 0 {

}

print(", ", terminator: "")

{{out}}

===Direct Approach===

loop n =

| else = ", "

===Using list===

loop [] = return ()

| else = ", "

This version is more generic and can work for any given range of values.

=={{header|Elixir}}==

def continue do

Enum.each(1..10, fn i ->

end

{{out}}

=={{header|Erlang}}==

-module(continue).

-export([main/0, for_loop/1]).

for_loop(N+1)

end.

{{out}}

<pre>1, 2, 3, 4, 5

=={{header|ERRE}}==

FOR I=1 TO 10 DO

PRINT(I;CHR$(29);) ! printing a numeric value leaves a blank after it

END FOR

PRINT

=={{header|Euphoria}}==

{{works with|Euphoria|4.0.3, 4.0.0 or later}}

for i = 1 to 10 do

end if

end for

Version without newline after 10 below.

for i = 1 to 10 do

end for

any_key()

=={{header|F Sharp|F#}}==

In any case, it is not needed to complete this task.

==={{trans|Ada}}===

printf "%d" i

if i % 5 = 0 then

printf "\n"

else

===Using [[Comma quibbling#The Function]]===

let fN g=quibble (Seq.initInfinite(fun n ->if (n+1)%5=0 || (n+1)=List.length g then "\n" else ", ")) g

fN [1] |> Seq.iter(fun(n,g)->printf "%d%s" n g)

fN [1..10] |> Seq.iter(fun(n,g)->printf "%d%s" n g)

fN [1..11] |> Seq.iter(fun(n,g)->printf "%d%s" n g)

{{out}}

<pre>

=={{header|Factor}}==

There is no built-in <code>continue</code> in Factor.

[ number>string write ]

[ 5 mod 0 = "\n" ", " ? write ] bi

=={{header|Fantom}}==

While and for loops support <code>continue</code> to jump back to begin the next iteration of the loop.

class LoopsContinue

{

}

}

=={{header|Forth}}==

Although this code solves the task, there is no portable equivalent to "continue" for either DO-LOOPs or BEGIN loops.

11 1 do

i dup 1 r.

5 mod 0= if cr else [char] , emit space then

=={{header|Fortran}}==

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

write(*, '(I0)', advance='no') i

if ( mod(i, 5) == 0 ) then

end if

write(*, '(A)', advance='no') ', '

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

C one nonstandard character on the line labelled 5001. Many F77

C compilers should be okay with it, but it is *not* standard.

5001 FORMAT (I3, ',', $)

C5001 FORMAT (I3, ',', ADVANCE='NO')

===Relying instead upon the looping features of FORMAT===

For historical reasons, 6 is often the default unit number for standard output.

WRITE (6,1) (I,I = 1,10)

1 FORMAT (4(1X,I0,","),1X,I0)

END

Here the break and continuation comes through the workings of the FORMAT interpreter. The feature 4(etc) means four repetitions of the format items within the brackets, and as each datum from the WRITE statement arrives, it is aligned with the next format item that can receive a datum, the I-format specifier (here I0, which means an integer of only as many digits as are needed for the value) and until such a reciever is encountered, intervening format items are acted upon - 1X means "one space", and the quotes surround a text literal. Accordingly, the first datum generates a space, a one-digit value, and a comma, as does the second and so on. When the sixth datum is received, the end of the format statement has been reached, and the convention is to write the current line and start a new line of output, and further, go back in the FORMAT specification to the first-encountered open-bracket symbol (the rightmost) which in this case is not the beginning of the FORMAT statement but the one that has a repetition count of four in front of it, and, resume interpretation. When the last datum has been accepted, naturally, the line is printed.

=={{header|FutureBasic}}==

long num

next

=={{header|Gambas}}==

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

Dim siCount As Short

Next

Output:

<pre>

=={{header|GAP}}==

if RemInt(i, 5) = 0 then

Print(i, "\n");

# 1, 2, 3, 4, 5

=={{header|GML}}==

{

show_message(string(i))

if(i <= 10)

continue

=={{header|Go}}==

import "fmt"

fmt.Printf(", ")

}

{{Out}}

<pre>

=={{header|Groovy}}==

print i

if (i % 5 == 0) {

}

print ', '

=={{header|Haskell}}==

The below code uses a guard (| symbol) to compose functions differently for the two alternative output paths, instead of using continue like in an imperative language.

main = forM [1..10] out

where

out x | x `mod` 5 == 0 = print x

=={{header|Haxe}}==

Sys.print(i);

if (i % 5 == 0) {

}

Sys.print(', ');

=={{header|HicEst}}==

IF( MOD(i, 5) == 1 ) THEN

WRITE(Format="i3") i

WRITE(APPend, Format=" ',', i3 ") i

ENDIF

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

The following code demonstrates the use of 'next' (the reserved word for 'continue'):

every writes(x := 1 to 10) do {

if x % 5 = 0 then {

writes(", ")

}

However, the output sequence can be written without 'next' and far more succinctly as:

=={{header|Io}}==

write(i)

if(i%5 == 0, writeln() ; continue)

write(" ,")

=={{header|J}}==

For example, one could satisfy this task this way:

J does support loops for those times they can't be avoided

(just like many languages support gotos for those time they can't be avoided).

z=.''

for_i. 1 + i.y do.

end.

i.0 0

Though it's rare to see J code like this.

=={{header|Java}}==

System.out.print(i);

if(i % 5 == 0){

}

System.out.print(", ");

=={{header|JavaScript}}==

Using the <code>print()</code> function from [[Rhino]] or [[SpiderMonkey]].

for (var i = 1; i <= 10; i++) {

output += i;

}

output += ", ";

For example:

return n ? rng(n - 1).concat(n) : [];

}

}, ''

)

Output:

6, 7, 8, 9, 10

=={{header|jq}}==

jq does not have a "continue" statement.

In jq 1.4, the simplest way to accomplish the given task is probably as follows:

=={{header|Jsish}}==

for (var i = 1; i <= 10; i++) {

printf("%d", i);

}

printf(", ");

{{out}}

=={{header|Julia}}==

for i in 1:10

print(i)

print(", ")

end

{{out}}

=={{header|Kotlin}}==

fun main(args: Array<String>) {

print("$i, ")

}

{{out}}

=={{header|Lambdatalk}}==

{def loops_continue

{lambda {:i}

-> 0, 1, 2, 3, 4, 5,

6, 7, 8, 9, 10. (end of loop)

=={{header|langur}}==

{{works with|langur|0.8.1}}

write .i

if .i div 5 { writeln(); next }

write ", "

=={{header|Lasso}}==

loop_count

loop_count % 5 ? ', ' | '\r'

loop_count < 100 ? loop_continue

'Hello, World!' // never gets executed

=={{header|Lingo}}==

repeat with i = 1 to 10

put i after str

put ", " after str

end repeat

=={{header|Lisaac}}==

i.print;

(i % 5 = 0).if { '\n'.print; } else { ','.print; };

=={{header|LiveCode}}==

put n

if n is 5 then put return

if n < 10 and n is not 5 then put ","

=={{header|Lua}}==

io.write( i )

if i % 5 == 0 then

io.write( ", " )

end

or

io.write( i )

if i % 5 == 0 then

io.write( ", " )

::continue::

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

Module Checkit {

\\ A For {} loop

}

Checkit

=={{header|Maple}}==

printf( "%d", i );

if irem( i, 5 ) = 0 then

end if;

printf( ", " )

This can also be done as follows, but without the use of "next".

printf( "%d%s", i, `if`( irem( i, 5 ) = 0, "\n", ", " ) )

=={{header|Mathematica}}/{{header|Wolfram Language}}==

For[i = 1, i <= 10, i++,

tmp = tmp <> ToString[i];

];

];

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

Loops are considered slow in Matlab and Octave,

it is preferable to vectorize the code.

or

A non-vectorized version of the code is shown below in Octave

printf(' %2d', i);

if ( mod(i, 5) == 0 )

continue

end

=={{header|Maxima}}==

block(

[s: ""],

)

)

=={{header|MAXScript}}==

(

format "%" i

) continue

format ", "

<nowiki>Insert non-formatted text here</nowiki>

As the [[Loop/Continue#Ada|Ada solution]], we can complete the task just with conditional.

for i = 1 step 1 until 10:

if i mod 5 = 0:

fi; endfor

message s;

Since <tt>message</tt> append always a newline at the end,

'''Note''': <tt>mod</tt> is not a built in; like TeX, "bare Metafont" is rather primitive, and normally a set of basic macros is preloaded to make it more usable; in particular <tt>mod</tt> is defined as

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

Module code and imports are omitted.

IO.PutInt(i);

IF i MOD 5 = 0 THEN

END;

IO.Put(", ");

=={{header|MOO}}==

for i in [1..10]

s += tostr(i);

endif

s += ", ";

=={{header|Neko}}==

Loops/Continue in Neko

Tectonics:

}

$print(", ");

{{out}}

=={{header|Nemerle}}==

{{trans|C#}}

using System.Console;

using Nemerle.Imperative;

}

}

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols nobinary

end i_

=={{header|NewLISP}}==

(print i)

(if (= 0 (% i 5))

(println)

=={{header|Nim}}==

{{trans|Python}}

if i mod 5 == 0:

echo i

continue

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

20 PRINT I;

30 IF I-I/5*5=0 THEN PRINT :GOTO 50"CONTINUE

40 PRINT ",";

=={{header|Objeck}}==

function : Main(args : String[]) ~ Nil {

for(i := 1; i <= 10; i += 1;) {

};

}

=={{header|OCaml}}==

There is no continue statement for for loops in OCaml,

but it is possible to achieve the same effect with an exception.

try

print_int i;

1, 2, 3, 4, 5

6, 7, 8, 9, 10

Though even if the continue statement does not exist,

it is possible to add it with camlp4.

=={{header|Octave}}==

for i = 1:10

v = sprintf("%s%d", v, i);

endif

v = sprintf("%s, ", v);

=={{header|Oforth}}==