Loops/Continue: Difference between revisions

{{task|Iteration}}

[[Category:Loop modifiers]]

{{omit from|GUISS}}

{{omit from|M4}}

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

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

6, 7, 8, 9, 10</pre>

 

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

<pre>

 

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

 

 

This sort of scheme facilitates a compact way of printing a table with a heading, where the WRITE statement simply pours forth the data and relies on something like FORMAT("heading",/,(complex details for one line)) - thus printing the table line-by-line with only the first line having the heading, a saving on having a write and format statement pair for the heading and a second pair for the table body.

 

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

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

 

| i |

10 loop: i [

i dup print 5 mod ifZero: [ printcr continue ]

"," .

 

=={{header|Oz}}==

By using the "continue" feature of the for-loop, we bind C to a nullary procedure which, when invoked, immediately goes on to the next iteration of the loop.

{System.print I}

if I mod 5 == 0 then

end

{System.printInfo ", "}

 

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

print1(n);

if(n%5 == 0, print();continue);

print1(", ")

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

print $_;

if ($_ % 5 == 0) {

}

print ', ';

 

It is also possible to use a goto statement

to jump over the iterative code section for a particular loop:

 

print $_;

if ($_ % 5 == 0) {

print ', ';

MYLABEL:

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">10</span> <span style="color: #008080;">do</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">", "</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">10</span> <span style="color: #008080;">do</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

 

=={{header|PHP}}==

echo $i;

if ($i % 5 == 0) {

}

echo ', ';

 

=={{header|PicoLisp}}==

PicoLisp doesn't have an explicit 'continue' functionality.

It can always be emulated with a conditional expression.

(print I)

(if (=0 (% I 5))

(prinl)

 

=={{header|Pike}}==

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

write(sprintf("%d",i));

write(", ");

}

 

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

do i = 1 to 10;

put edit (i) (f(3));

if mod(i,5) = 0 then do; put skip; iterate loop; end;

put edit (', ') (a);

 

=={{header|Plain English}}==

In Plain English, continue is spelled <code>repeat</code> and is the only way to specify an end of a loop.

Start up.

Demonstrate continue.

If the counter is evenly divisible by 5, write "" on the console; repeat.

Write ", " on the console without advancing.

 

=={{header|Pop11}}==

for i from 1 to 10 do

printf(i, '%p');

endif;

printf(', ')

 

=={{header|PowerShell}}==

{{trans|C}}

Write-Host -NoNewline $i

if ($i % 5 -eq 0) {

}

Write-Host -NoNewline ", "

 

=={{header|Python}}==

if i % 5 == 0:

continue

 

=={{header|Quackery}}==

[ i^ 1+ dup echo

5 mod 0 = iff

cr done

 

=={{header|R}}==

{{trans|C++}}

{

cat(i)

}

cat(", ")

 

=={{header|Racket}}==

but an explicit <tt>continue</tt> construct is rarely used:

 

#lang racket

 

(printf "~a~n" i)))

(printf "~a, " i))

 

=={{header|Raku}}==

{{trans|Perl}}

{{works with|Rakudo Star|2010.08}}

.print;

if $_ %% 5 {

}

print ', ';

 

or without using a loop:

 

 

=={{header|REBOL}}==

Title: "Loop/Continue"

URL: http://rosettacode.org/wiki/Loop/Continue

prin ", "

]

 

{{Out}}

 

=={{header|Red}}==

prin i

if i = 10 [break]

]

1,2,3,4,5

 

=={{header|REXX}}==

===version 1===

(This program could be simpler by using a &nbsp; '''then/else''' &nbsp; construct, but an &nbsp; '''iterate''' &nbsp; was used to conform to the task.)

 

do j=1 for 10 /*this is equivalent to: DO J=1 TO 10 */

say /*force REXX to display on next line. */

end /*j*/

Program note: &nbsp; the comma (<big><b>,</b></big>) immediately after the &nbsp; '''charout''' &nbsp; BIF indicates to use the terminal output stream.

 

 

===version 2===

$= /*nullify the variable used for display*/

do j=1 for 10 /*this is equivalent to: DO J=1 TO 10 */

if j==5 then $= /*start the display line over again. */

end /*j*/

'''output''' &nbsp; is the same as the 1^st REXX version. <br><br>

 

=={{header|Ring}}==

for i = 1 TO 10

see i

see ", "

next

 

=={{header|Ruby}}==

print i

if i % 5 == 0 then

end

print ', '

The "for" look could be written like this:

1.upto(10) do |i| ...

Without meeting the criteria (showing loop continuation), this task could be written as:

 

=={{header|Rust}}==

for i in 1..=10 {

print!("{}", i);

print!(", ");

}

 

=={{header|Salmon}}==

{

print(x);

};

print(", ");

 

=={{header|Sather}}==

There's no <code>continue!</code> in Sather. The code solve the task without forcing a new iteration.

main is

i:INT;

end;

end;

 

=={{header|Scala}}==

 

===The intuitive way===

print(i)

if (i % 5 == 0) println() else print(", ")

 

===Functional solution===

#The map makes for both elements in the List a conversion to a comma separated String, yielding a List of two Strings.

#Both comma separated strings will be separated by an EOL

 

=={{header|Scheme}}==

 

=={{header|Scilab}}==

{{works with|Scilab|5.5.1}}

printf("%2d ",i)

if modulo(i,5)~=0 then

end

printf("\n")

{{out}}

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

 

=={{header|Sidef}}==

print i

if (i %% 5) {

}

print ', '

 

=={{header|Simula}}==

{{works with|SIMULA-67}}

begin

integer i;

loop:

end

{{out}}

<pre>

=={{header|Smalltalk}}==

{{works with|Pharo}} {{works with|Smalltalk/X}} actually works with all dialects &sup1;

1 to: 10 do: [ :i |

[ :continue |

] valueWithExit.

]

&sup1; if valueWithExit is not present in the Block class, it can be added as:

 

=={{header|Spin}}==

{{works with|HomeSpun}}

{{works with|OpenSpin}}

_clkmode = xtal1 + pll16x

_clkfreq = 80_000_000

waitcnt(_clkfreq + cnt)

ser.stop

{{out}}

<pre>

 

=={{header|SPL}}==

s += n

? n%5, s += ", "

#.output(s)

s = ""

{{out}}

<pre>

{{works with|Db2 LUW}} version 9.7 or higher.

With SQL PL:

--#SET TERMINATOR @

 

END WHILE Loop;

END @

Output:

<pre>

See '''[https://www.stata.com/help.cgi?continue continue]''' in Stata help. Notice that the _continue option of '''[https://www.stata.com/help.cgi?display display]''' has another purpose: it suppresses the automatic newline at the end of the display command.

 

display `n' _continue

if mod(`n',5)==0 {

}

display ", " _continue

 

=={{header|Suneido}}==

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

{

}

}

 

{{Out}}

6,7,8,9,10

 

=={{header|Swift}}==

print(i, terminator: "")

if i % 5 == 0 {

}

print(", ", terminator: "")

{{Out}}

<pre>

 

=={{header|Tcl}}==

puts -nonewline $i

if {$i % 5 == 0} {

}

puts -nonewline ", "

 

=={{header|Transact-SQL}}==

 

DECLARE @i INT = 0;

DECLARE @str VarChar(40) = '';

SET @str = @str +', ';

END;

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

numbers=""

numbers=""

ENDLOOP

{{Out}}

<pre>

 

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

while (( Z<=10 )); do

echo -e "$Z\c"

fi

(( Z++ ))

 

{{works with|Bash}}

echo -n $i

if [ $((i%5)) -eq 0 ]; then

fi

echo -n ", "

 

=={{header|UnixPipes}}==

 

=={{header|Ursa}}==

{{trans|Python}}

for (set i 1) (< i 11) (inc i)

if (= (mod i 5) 0)

end if

out i ", " console

 

=={{header|Vala}}==

stdout.printf("%d", i);

if (i % 5 == 0) {

}

stdout.printf(", ");

 

=={{header|VBA}}==

Dim value As Integer

For value = 1 To 10

End If

Next value

 

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

Num_Type(#1, LEFT+NOCR)

if (#1 % 5 == 0) {

}

Message(", ")

 

=={{header|Wren}}==

From v0.4.0 Wren has a ''continue'' keyword which works in the expected fashion.

System.write(i)

if (i%5 == 0) {

}

 

 

{{out}}

The way you implement continue in X86 Assembly is the same way as how you would create a loop:

you just implement a (conditional) jump to another line of code.

extern _printf

 

pop ebx

ret

{{Out}}

<pre>

=={{header|XBasic}}==

{{works with|Windows XBasic}}

PROGRAM "loopcontinue"

 

END FUNCTION

END PROGRAM

{{Out}}

<pre>

Only the first three characters of a command are required.

 

integer N;

for N:= 1 to 10 do

 

{{Out}}

 

=={{header|Yabasic}}==

print str$(i);

if mod(i, 5) = 0 then

next

print

 

 

=={{header|zkl}}==