Loops/N plus one half: Difference between revisions

 

Quite often one needs loops which, in the last iteration, execute only part of the loop body.

 

;Goal:

Demonstrate the best way to do this.

 

;Task:

using separate output statements for the number

and the comma from within the body of the loop.

 

;Related tasks:

 

=={{header|11l}}==

print(i, end' ‘’)

I !L.last_iteration

 

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

=={{header|68000 Assembly}}==

Sega Genesis cartridge header and hardware print routines/bitmap font are omitted here but do work as intended.

move.w #1,d1 ;ABCD can't use an immediate operand

move.w #10-1,d2

; include "X:\SrcGEN\testModule.asm"

{{out}}

<pre>01, 02, 03, 04, 05, 06, 07, 08, 09, 10</pre>

Since the output of the last element is different than the rest, the easiest way to accomplish this is by "breaking out" of the loop with a comparison to 10.

 

.stack 1024

 

pop ax

ret

 

{{out}}

ACL2 does not have loops, but this is close:

 

(progn$ (cw "~x0" (first xs))

(if (endp (rest xs))

(cw (coerce '(#\Newline) 'string))

(progn$ (cw ", ")

 

=={{header|Action!}}==

i==+1

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/N_plus_one_half.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

 

procedure LoopsAndHalf is

end loop;

Ada.Text_IO.new_line;

 

=={{header|Aime}}==

 

i = 0;

o_text(", ");

}

 

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

{{works with|ALGOL 60|OS/360}}

'COMMENT' Loops N plus one half - Algol60 - 20/06/2018;

'INTEGER' I;

'IF' I 'NOTEQUAL' 10 'THEN' OUTSTRING(1,'(', ')')

'END'

{{out}}

<pre>

There are three common ways of achieving n+½ loops:

{|border="1" style="border-collapse: collapse;"

print(whole(i, -2));

# WHILE # i < 10 DO

OD;

 

print(whole(i, -2));

IF i < 10 THEN

OD;

 

print(whole(i, -2));

IF i >= 10 THEN GO TO done FI;

OD;

done:

|}

Output for all cases above:

 

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

integer i;

i := 0;

writeon( "," )

end

 

=={{header|AmigaE}}==

DEF i

FOR i := 1 TO 10

WriteF(', ')

ENDFOR

 

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

 

=={{header|ArnoldC}}==

HEY CHRISTMAS TREE n

YOU SET US UP @NO PROBLEMO

ENOUGH TALK

CHILL

 

=={{header|Arturo}}==

 

 

{{out}}

 

=={{header|Asymptote}}==

write(i, suffix=none);

if(i < 10) write(", ", suffix=none);

{{out}}

<pre>1, 2, 3, 4, 5, 6, 7, 8, 9, 10</pre>

 

=={{header|AutoHotkey}}==

{

output .= A_Index ; append the index of the current loop to the output var

output .= ", " ; append ", " to the output var

}

 

=={{header|AutoIt}}==

 

AutoIt Version: 3.3.8.1

EndFunc

 

 

=={{header|AWK}}==

'''One-liner:'''

{{out}}

<pre>

}

print

Same output.

 

=={{header|Axe}}==

Disp I▶Dec

If I=10

Disp ","

End

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

{{works with|RapidQ}}

 

FOR i=1 TO 10

IF i=10 THEN EXIT FOR

PRINT ", ";

 

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

{{works with|Commodore BASIC}}

The [[#ZX_Spectrum_Basic|ZX Spectrum Basic]] code will work just fine in Applesoft BASIC. The following is a more structured approach which avoids the use of GOTO.

20 PRINT I;

 

==={{header|ASIC}}===

 

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

print i;

if i < 10 then print ", ";

next i

 

 

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

PRINT ; i% ;

IF i% <> 10 PRINT ", ";

NEXT

 

==={{header|Chipmunk Basic}}===

{{works with|Chipmunk Basic|3.6.4}}

20 c$ = ""

30 for i = 1 to 10

40 print c$;str$(i);

50 c$ = ", "

 

==={{header|FBSL}}===

IF i < 10 THEN PRINT ", ";

Next

Output

<pre>1, 2, 3, 4, 5, 6, 7, 8, 9, 10

 

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

 

For i As Integer = 1 To 10

 

Print

{{out}}

<pre>

====Alternative====

This makes the important point that for many loops of this kind the partial iteration could easily be the ''first'' one.

for i as ubyte = 1 to 10

print cm;str(i);

cm = ", "

 

==={{header|FutureBasic}}===

 

long i, num = 10

next i

 

{{out}}

<pre>

==={{header|Gambas}}===

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

Dim siLoop As Short

 

Next

 

{{out}}

<pre>

 

==={{header|GW-BASIC}}===

20 FOR I = 1 TO 10

30 PRINT C$;STR$(I);

40 C$=", "

 

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

110 PRINT I;

120 IF I=10 THEN EXIT FOR

130 PRINT ",";

 

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

 

==={{header|Microsoft Small Basic}}===

TextWindow.Write(i)

If i <> 10 Then

EndIf

EndFor

 

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

20 PRINT I;

30 IF I=10 THEN GOTO 50

40 PRINT ",";

 

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

Repeat

Print(Str(x))

If x>10: Break: EndIf

Print(", ")

 

==={{header|QBasic}}===

{{works with|QBasic|1.1}}

{{works with|QuickBasic|4.5}}

PRINT USING "##"; i;

IF i=10 THEN EXIT FOR

PRINT ", ";

 

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

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

The [[#ZX_Spectrum_Basic|ZX Spectrum Basic]] program will work on the ZX81. Depending on the context, the programmer's intention may be clearer if we do it all with <code>GOTO</code>s instead of a <code>FOR</code> loop.

20 PRINT I;

30 IF I=10 THEN GOTO 70

40 PRINT ", ";

50 LET I=I+1

 

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

There is no horizontal cursor position on the program IO screen, so we concatenate strings instead.

"" → str

For i,1,10

EndIf

EndFor

 

==={{header|Tiny BASIC}}===

Tiny BASIC does not support string concatenation so each number is on a separate line but this is at least in the spirit of the task description.

10 IF I = 10 THEN PRINT I

IF I < 10 THEN PRINT I,", "

IF I = 10 THEN END

LET I = I + 1

 

A solution for the dialects of Tiny BASIC that support string concatenation.

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

{{works with|QBasic}}

FOR i = 1 to 10

PRINT cm$; str$(i);

LET cm$ = ", "

NEXT i

 

==={{header|VBA}}===

Dim i As Integer

Dim a(1 To 10) As String

Next i

Debug.Print Join(a, ", ")

 

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

Console.Write(i)

If i = 10 Then Exit For

Console.Write(", ")

 

==={{header|Wee Basic}}===

print 1 "" ensures the end of program text is separate from the list of numbers.

for numbers=1 to 10

print 1 at numbers*3-2,0 numbers

print 1 at numbers*3-1,0 ","

endif

 

==={{header|XBasic}}===

 

==={{header|Yabasic}}===

print i;

if i < 10 print ", ";

next i

print

 

==={{header|ZX Spectrum Basic}}===

{{works with|Commodore BASIC}}

To terminate a loop on the ZX Spectrum, set the loop counter to a value that will exit the loop, before jumping to the NEXT statement.

20 PRINT i;

30 IF i=10 THEN GOTO 50

40 PRINT ", ";

 

=={{header|bc}}==

{{Works with|GNU bc}}

The <code>print</code> extension is necessary to get the required output.

print ++i

if (i == 10) {

}

print ", "

 

=={{header|Befunge}}==

This code is a good answer. However, most Befunge implementations print a " " after using . (output number), so this program prints "1 , 2 , 3 ..." with extra spaces. A bypass for this is possible, by adding 48 and printing the ascii character, but does not work with 10::

 

=={{header|Bracmat}}==

& whl

' ( put$!i

& !i+1:~>10:?i

& put$", "

 

=={{header|C}}==

{{trans|C++}}

 

int main()

}

return 0;

 

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

 

class Program

Console.WriteLine();

}

 

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

int main()

 

=={{header|Chapel}}==

 

=={{header|Clojure}}==

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

PROGRAM-ID. Loop-N-And-Half.

 

 

GOBACK

Free-form, 'List'-free version, using DISPLAY NO ADVANCING.

PROGRAM-ID. LOOP-1p5-NOADV.

DATA DIVISION.

END-PERFORM.

STOP RUN.

Free-form, GO TO, 88-level. Paragraphs in PROCEDURE DIVISION.

PROGRAM-ID. LOOP-1p5-NOADV-GOTO.

DATA DIVISION.

02-DONE.

STOP RUN.

Using 'PERFORM VARYING'

PROGRAM-ID. LOOP-1p5-NOADV-VARY.

DATA DIVISION.

END-PERFORM.

STOP RUN.

 

=={{header|CoffeeScript}}==

=={{header|ColdFusion}}==

With tags:

#i#

<cfif i EQ 10>

</cfif>

,

 

With script:

for( i = 1; i <= 10; i++ ) //note: the ++ notation works only on version 8 up, otherwise use i=i+1

{

writeOutput( ", " );

}

 

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

or

 

(princ i)

(if (= i 10) (return))

 

but for such simple tasks we can use format's powers:

 

=={{header|Cowgol}}==

 

var i: uint8 := 1;

i := i + 1;

end loop;

 

{{out}}

=={{header|D}}==

===Iterative===

void main() {

 

writeln();

{{out}}

<pre>1, 2, 3, 4, 5, 6, 7, 8, 9, 10</pre>

===Functional Style===

import std.stdio, std.range, std.algorithm, std.conv, std.string;

iota(1, 11).map!text.join(", ").writeln;

// A simpler solution:

writefln("%(%d, %)", iota(1, 11));

{{out}}

<pre>1, 2, 3, 4, 5, 6, 7, 8, 9, 10

 

=={{header|Dart}}==

var result = '';

for(int i = start; i <= end; i++) {

void main() {

print(loopPlusHalf(1, 10));

 

=={{header|Delphi}}==

 

 

{$APPTYPE CONSOLE}

end;

Writeln;

 

=={{header|Draco}}==

byte i;

i := 1;

write(", ")

od

{{out}}

<pre>1, 2, 3, 4, 5, 6, 7, 8, 9, 10</pre>

=={{header|DWScript}}==

 

 

for i := 1 to 10 do begin

if i < 10 then

Print(', ');

 

=={{header|E}}==

 

A typical loop+break solution:

while (true) {

print(i)

print(", ")

i += 1

 

Using the loop primitive in a semi-functional style:

 

__loop(fn {

print(i)

true

}

 

=={{header|EasyLang}}==

 

=={{header|EDSAC order code}}==

=======================

 

[ 25 ] PF

 

{{out}}

<pre>1, 2, 3, 4, 5, 6, 7, 8, 9, 10</pre>

 

=={{header|Elixir}}==

def n_plus_one_half([]), do: IO.puts ""

def n_plus_one_half([x]), do: IO.puts x

end

 

 

=={{header|Erlang}}==

-module(loop).

-export([main/0]).

 

=={{header|Factor}}==

[ [1,b] ] keep '[

[ number>string write ]

[ _ = [ ", " write ] unless ] bi

 

=={{header|Falcon}}==

formiddle

>> value

end

forlast: > value

 

{{out}}

 

=={{header|FALSE}}==

 

=={{header|Fantom}}==

 

=={{header|Forth}}==

dup 1 ?do i 1 .r ." , " loop

 

dup 1+ 1 do

i 1 .r

dup i = if leave then \ or DROP UNLOOP EXIT to exit loop and the function

[char] , emit space

 

1

begin dup 1 .r

2dup <>

while ." , " 1+

 

=={{header|Fortran}}==

{{works with|FORTRAN|IV and later}}

INTEGER I

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

301 FORMAT((I3,','))

 

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

 

C two nonstandard characters on the lines labelled 5001 and 5002.

C Many F77 compilers should be okay with it, but it is *not*

C5001 FORMAT (T3, ADVANCE='NO')

C5001 FORMAT (A, ADVANCE='NO')

 

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

 

do

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

i = i + 1

end do

 

=={{header|GAP}}==

for i in [1 .. n] do

Print(i);

Print("\n");

fi;

 

=={{header|GML}}==

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

{

str += ", "

}

 

=={{header|Go}}==

 

import "fmt"

fmt.Print(", ")

}

 

=={{header|Gosu}}==

for(i in 1..10) {

if(i > 1) out.print(", ")

out.print(i)

 

=={{header|Groovy}}==

Solution:

print i

if (i == 10) break

print ', '

 

Output:

 

=={{header|Haskell}}==

main = forM_ [1 .. 10] $ \n -> do

putStr $ show n

 

You can also use intersperse :: a -> [a] -> [a]

 

=={{header|Haxe}}==

 

=={{header|hexiscript}}==

print i

if i = 10; break; endif

print ", "

endfor

 

=={{header|HicEst}}==

WRITE(APPend) i

IF(i < 10) WRITE(APPend) ", "

 

=={{header|HolyC}}==

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

Print("%d", i);

Print(", ");

}

 

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

every writes(i := 1 to 10) do

if i = 10 then break write()

else writes(", ")

 

The above can be written more succinctly as:

</syntaxhighlight>

 

Nobody would ever use a loop in IDL to output a vector of numbers - the requisite output would be generated something like this:

 

 

However if a loop had to be used it could be done like this:

 

print,i,format='($,i)'

if i lt 10 then print,",",format='($,a)'

 

(which merely suppresses the printing of the comma in the last iteration);

or like this:

 

print,i,format='($,i)'

if i eq 10 then break

print,",",format='($,a)'

 

(which terminates the loop early if the last element is reached).

 

=={{header|J}}==

buffer=: buffer,y

)

end.

echo buffer

 

Example use:

 

That said, note that neither loops nor output statements are necessary:

 

 

And, note also that this sort of data driven approach can also deal with more complex issues:

 

commaAnd i.5

 

=={{header|Java}}==

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

System.out.print(i);

}

System.out.println();

 

=={{header|JavaScript}}==

var str = '',

i;

}

 

Alternatively, if we stand back for a moment from imperative assumptions about the nature and structure of computing tasks, it becomes clear that the problem of special transitional cases as a pattern terminates has no necessary connection with loops. (See the comments accompanying the ACL2, Haskell, IDL, J and R examples above and below, and see also some of the approaches taken in languages like Clojure and Scala.

If a JavaScript expression evaluates to an array [1 .. 10] of integers, for example, we can map that array directly to a comma-delimited string by using the '''Array.join()''' function, writing something like:

 

return Array.apply(null, Array(n - m + 1)).map(

function (x, i) {

console.log(

range(1, 10).join(', ')

 

Output:

 

Otherwise, any special transitional case at the end of a pattern can be handled by defining conditional values for one or more sub-expressions:

 

return Array.apply(null, Array(n - m + 1)).map(function (x, i) {

return m + i;

)

})(1, 10)

 

Output:

==== Otherwise ====

for (var i=s; i<=e; i+=1) {

document.write( i==s ? '' : ', ', i )

or

for (;; s+=1) {

document.write( s )

if (s==e) break

document.write( ', ' )

{{out}}

<pre>

=={{header|jq}}==

In jq, it is idiomatic to view a range of integers with boundaries m and n as [m, n), i.e. including m but excluding n.

def loop_plus_half(m;n):

if m<n then reduce range(m+1;n) as $i (m|tostring; . + ", " + ($i|tostring))

# An alternative that is shorter and perhaps closer to the task description because it uses range(m;n) is as follows:

def loop_plus_half2(m;n):

{{Out}}

loop_plus_half2(1;11)

 

=={{header|K}}==

i:1;do[10;p[i];p[:[i<10;", "]];i+:1];p@"\n"

 

Alternative solutions:

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

if (i < 10) print(", ")

}

 

{{out}}

 

=={{header|Lang5}}==

Word: [[Loops/For#Lang5]]

: , dup 10 != if ", " 2string then ;

 

=={{header|Lasso}}==

loop(10) => {

#out->append(loop_count)

#out->append(', ')

}

 

=={{header|Lhogho}}==

<code>type</code> doesn't output a newline. The <code>print</code> outputs one.

[

type :i

]

]

 

A more list-y way of doing it

 

if list? :lst

[

 

make "aList [1 2 3 4 5 6 7 8 9 10]

 

=={{header|Lisaac}}==

 

+ name := LOOP_AND_HALF;

};

'\n'.print;

 

=={{header|LiveCode}}==

put n after loopn

if n is not 10 then put comma after loopn

end repeat

 

=={{header|Logo}}==

repeat :n-1 [type repcount type "|, |]

print :n

end

 

 

=={{header|Lua}}==

Translation of C:

io.write(i)

if i == 10 then break end

io.write", "

 

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

 

=={{header|M4}}==

`define(`ulim',llim)')

define(`for',

 

for(`x',`1',`',

 

=={{header|Make}}==

MAX=10

RES=1

 

%-n:

 

Invoking it

 

=={{header|Maple}}==

 

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

While[True,

s = s <> ToString@i;

i++;

]

 

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

Vectorized form:

 

Explicite loop:

printf('%i', k);

if k==10, break; end;

printf(', ');

end;

 

Output:

 

=={{header|MAXScript}}==

(

format "%" i

if i == 10 then exit

format "%" ", "

 

=={{header|Metafont}}==

and then we output it.

 

string s; s := "";

for i = 1 upto last:

endfor

message s;

 

=={{header|min}}==

min's <code>linrec</code> combinator is flexible enough to easily accomodate this task, due to taking a quotation to execute at the end of the loop (the second one).

 

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

 

IMPORT IO, Fmt;

END;

IO.Put("\n");

 

=={{header|MUMPS}}==

NEW I

FOR I=1:1:10 DO

;Alternate

NEW I FOR I=1:1:10 WRITE I WRITE:I'=10 ", "

Output:<pre>USER>D LOOPHALF^ROSETTA

1, 2, 3, 4, 5, 6, 7, 8, 9, 10

 

=={{header|Nemerle}}==

{

Write(i);

unless (i == 10) Write(", ");

 

=={{header|NetRexx}}==

/* NetRexx */

options replace format comments java crossref savelog symbols nobinary

end

end i_

'''Output'''

<pre>Loops/N plus one half

 

=={{header|NewLISP}}==

(print i)

(unless (= i 10)

 

=={{header|Nim}}==

for i in 1..10:

s.add $i

if i == 10: break

s.add ", "

 

{{out}}

<pre>1, 2, 3, 4, 5, 6, 7, 8, 9, 10</pre>

 

=={{header|Objeck}}==

 

=={{header|OCaml}}==

for i = 1 to last do

print_int i;

print_string ", ";

done;

 

let str_ints = List.map string_of_int ints in

 

=={{header|Oforth}}==

 

| i |

 

=={{header|Oz}}==

if N == 10 then {Break} end

{System.printInfo ", "}

 

However, it seems more natural to use a left fold:

fun {CommaSep Xs}

case Xs of nil then nil

end

in

 

=={{header|Panda}}==

Panda is stream based. To know if there is no more values you need to know it's the last. You can only do that if you get all the values. So this is functional style; We accumulate all the values from the stream. Then join them together as strings with a comma.

 

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

while(1,

print1(n++);

if(n>9, break);

print1(", ")

 

=={{header|Pascal}}==

 

const MAXNUM: integer = 10;

write(i, ', ');

writeln(MAXNUM);

 

=={{header|Peloton}}==

 

=={{header|Perl}}==

print $i;

last if $i == 10;

print ', ';

}

 

In perl one would solve the task via <code>join</code>.

 

=={{header|Phix}}==

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

 

=={{header|Phixmonti}}==

by Galileo, 11/2022 #/

 

{{out}}

<pre>1, 2, 3, 4, 5, 6, 7, 8, 9, 10

 

=={{header|PHP}}==

echo $i;

if ($i == 10)

echo ', ';

}

 

=={{header|PicoLisp}}==

(prin N)

(T (= N 10))

 

=={{header|Pike}}==

}

write("\n");

 

The most idiomatic way of inserting delimiters in Pike is the multiplication operator and it's symmetry with division of strings.

Result: ({ "1", "2", "3" })

> ({ "1", "2", "3" })*", ";

 

So achieving the result of this task with the method more suited to

Pike would be:

 

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

 

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

Start up.

Write the numbers up to 10 on the console.

Write the string on the console without advancing.

If the counter is less than the number, write ", " on the console without advancing.

 

=={{header|Pop11}}==

for i from 1 to 10 do

printf(i, '%p');

printf(', ', '%p');

endfor;

 

=={{header|PowerShell}}==

{{trans|C}}

Write-Host -NoNewLine $i

if ($i -eq 10) {

}

Write-Host -NoNewLine ", "

An interesting alternative solution, although not ''strictly'' a loop, even though <code>switch</code> certainly loops over the given range.

{ $true } { Write-Host -NoNewLine $_ }

{ $_ -lt 10 } { Write-Host -NoNewLine ", " }

{ $_ -eq 10 } { Write-Host }

 

=={{header|Prolog}}==

between(1,10,Val), write(Val), Val<10, write(', '), fail.

<pre>?- example.

1, 2, 3, 4, 5, 6, 7, 8, 9, 10

=={{header|Python}}==

The particular pattern and example chosen in the task description is recognised by the Python language and there are more idiomatic ways to achieve the result that don't even require an explicit conditional test such as:

But the [http://academicearth.org/lectures/the-loop-and-half-problem named pattern] is shown by code such as the following:

>>> write = stdout.write

>>> n, i = 10, 1

1, 2, 3, 4, 5, 6, 7, 8, 9, 10

 

List comprehension one-liner

 

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

while True:

print(i, end="")

if i > n:

break

 

=={{header|Quackery}}==

 

[ i^ 1+ echo

i 0 = iff

conclude done

 

{{out}}

=={{header|R}}==

The natural way to solve this task in R is:

The task specifies that we should use a loop however, so this more verbose code is needed.

{

cat(i)

}

cat(", ")

 

=={{header|Racket}}==

(for ((i (in-range 1 15)))

(display i)

#:break (= 10 i)

 

Gives the desired output.

}

 

 

=={{header|REBOL}}==

Title: "Loop Plus Half"

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

prin ", "

]

 

=={{header|Red}}==

 

repeat i 10 [

prin ", "

]

 

=={{header|Relation}}==

=={{header|REXX}}==

===two CHAROUTs===

 

do j=1 to 10

if j<10 then call charout ,"," /*append a comma for one-digit numbers.*/

end /*j*/

'''output'''

<pre>

 

===one CHAROUT===

 

do j=1 for 10 /*using FOR is faster than TO. */

call charout ,j || left(',',j<10) /*display J, maybe append a comma (,).*/

end /*j*/

'''output'''

<pre>

 

===version 3 if the number of items is not known===

sep=', '

Do i=1 By 1 While list<>''

Parse Var list item list

Call charout ,item

{{out}}

<pre>aa, bb, cc, dd</pre>

print ", "

end

More idiomatic Ruby to obtain the same result is:

<syntaxhighlight lang="ruby">

 

=={{header|Rust}}==

for i in 1..=10 {

print!("{}{}", i, if i < 10 { ", " } else { "\n" });

}

 

More like the problem description:

for i in 1..=10 {

print!("{}", i);

}

println!();

 

println!(

"{}",

.join(", ")

);

 

=={{header|S-lang}}==

part from the bottom to the top of the loop, then NOT include it on the

FIRST pass:

foreach i ([1:10]) {

if (more) () = printf(", ");

printf("%d", i);

more = 1;

 

=={{header|Salmon}}==

{

print(x);

print(", ");

};

 

=={{header|Scala}}==

{{libheader|Scala}}

while ({

print(i)

i += 1

}

 

=={{header|Scheme}}==

It is possible to use continuations:

(lambda (esc)

(do ((i 1 (+ 1 i))) (#f)

(display i)

(if (= i 10) (esc (newline)))

 

But usually making the tail recursion explicit is enough:

(display i)

(if (= i 10)

(begin

(display ", ")

 

=={{header|Scilab}}==

{{works with|Scilab|5.5.1}}

printf("%2d ",i)

if i<10 then printf(", "); end

end

{{out}}

<pre> 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 </pre>

 

=={{header|Seed7}}==

 

const proc: main is func

end for;

writeln;

 

=={{header|Sidef}}==

print i;

i == 10 && break;

}

 

 

=={{header|Smalltalk}}==

Transcript show: n asString.

n < 10 ifTrue: [ Transcript show: ', ' ]

Smalltalk/X and Pharo/Squeak have special enumeration messages for this in their Collection class, which executes another action in-between iterated elements:

{{works with|Smalltalk/X}}{{works with|Pharo}}

Transcript show: n asString.

] separatedBy:[

Transcript show: ', '

That is a bit different from the task's specification, but does what is needed here, and is more general in working with any collection (in the above case: a range aka "Interval"). It does not depend on the collection being addressed by an integer index and/or keeping a count inside the loop.

 

line output, and to use the same statement for loop control and the comma.

 

str = str ne(i,10) ',' :s(loop)

out output = str

 

{{works with|Macro Spitbol}}

 

This example also breaks the loop explicitly:

loop i = lt(i,10) i + 1 :f(end)

out = i

eq(i,10) :s(end)

out = ',' :(loop)

 

{{out}}

 

=={{header|SNUSP}}==

| | \@@@+@+++++# \>>.<.<</ comma and space

| \@@+@@+++++#

 

=={{header|Spin}}==

{{works with|HomeSpun}}

{{works with|OpenSpin}}

_clkmode = xtal1 + pll16x

_clkfreq = 80_000_000

waitcnt(_clkfreq + cnt)

ser.stop

{{out}}

<pre>

 

=={{header|Stata}}==

di `i' _continue

if `i'<10 {

di

}

 

=== Mata ===

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

printf("%f",i)

}

}

 

=={{header|Swift}}==

{{works with|Swift|1.x}}

print(i)

if i == 10 {

}

print(", ")

{{works with|Swift|2}} The usual way to do this with Swift 2 is:

<syntaxhighlight lang="swift">

</syntaxhighlight>

To satisfy the specification, we have to do something similar to Swift 1.x and other C-like languages:

print(i, terminator: "")

if i == 10 {

}

print(", ", terminator: "")

 

=={{header|Tcl}}==

puts -nonewline $i

if {$i >= $end} break

puts -nonewline ", "

}

However, that's not how the specific task (printing 1..10 with comma separators) would normally be done. (Note, the solution below is ''not'' a solution to the half-looping problem.)

set result {}

for {set i $from} {$i <= $to} {incr i} {

}

 

=={{header|TUSCRIPT}}==

 

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

echo -e "$Z\c"

if (( Z != 10 )); then

echo -e ", \c"

fi

 

{{works with|Bash}}

echo -n $i

[ $i -eq $last ] && break

echo -n ", "

 

=={{header|UnixPipes}}==

The last iteration is handled automatically for us

when there is no element in one of the pipes.

 

=={{header|Ursa}}==

{{trans|PHP}}

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

out i console

out ", " console

end for

 

=={{header|V}}==

[ [10 =] [puts]

[true] [dup put ',' put succ loop]

Using it

|1 loop

=={{header|Vala}}==

{{trans|C}}

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

{

stdout.printf(i == 10 ? "\n" : ", ");

}

 

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

This example writes the output into current edit buffer.

Num_Ins(#1, LEFT+NOCR)

if (#1 == 10) { Break }

Ins_Text(", ")

}

 

=={{header|Verilog}}==

integer i;

$finish ;

end

{{out}}

<pre>1, 2, 3, 4, 5, 6, 7, 8, 9, 10</pre>

 

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

echon i

if (i != 10)

echon ", "

endif

 

=={{header|V (Vlang)}}==

for i := 1; ; i++ {

print(i)

print(", ")

}

 

=={{header|Wart}}==

pr i

if (i < 10)

pr ", "

 

=={{header|Wren}}==

System.write(i)

System.write((i < 10) ? ", " : "\n")

{{out}}

<pre>

 

=={{header|XPL0}}==

int N;

[for N:= 1 to 10 do \best way to do this

];

CrLf(0);

 

=={{header|zkl}}==

Or, using a state machine:

where pump is (sink, action, action ...). The first Drop writes the

first object from the source (1) to the sink and drops out (and that

collects things to write to the sink: a comma and the number, eg ",2".

Or:

 

=={{header|Zig}}==

pub fn main() !void {

const stdout_wr = std.io.getStdOut().writer();

}

}

 

{{omit from|PL/0}}