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

* Loops/N plus one half 13/08/2015

LOOPHALF CSECT USING LOOPHALF,R12

YREGS

END LOOPHALF

{{out}}

<pre>

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

</pre>

 

=={{header|8086 Assembly}}==

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

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program loopnplusone64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{Output}}

<pre>

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

BYTE i=[1]

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program loopnplusone.s */

bx lr @ return

 

 

=={{header|ArnoldC}}==

HEY CHRISTMAS TREE n

YOU SET US UP @NO PROBLEMO

ENOUGH TALK

CHILL

 

=={{header|Arturo}}==

 

 

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

 

'''Readable version:'''

BEGIN {

n=10

}

print

Same output.

 

=={{header|Axe}}==

Disp I▶Dec

If I=10

Disp ","

End

 

=={{header|BASIC}}==

{{works with|FreeBASIC}}

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

PROCEDURE nAndAHalf

DIM i:INTEGER

NEXT i

PRINT

 

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

print i;

if i < 10 then print ", ";

next i

 

 

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

PRINT ; i% ;

IF i% <> 10 PRINT ", ";

NEXT

 

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

{{works with|QBasic}}

FOR i = 1 to 10

PRINT cm$; str$(i);

LET cm$ = ", "

NEXT i

 

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

return 0;

}

 

=={{header|Chapel}}==

 

=={{header|Clojure}}==

; Functional version

(apply str (interpose ", " (range 1 11)))

(print ", ")

(recur (inc n)))))

 

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

# Loop plus half. This code shows how to break out of a loop early

# on the last iteration. For the contrived example, there are better

s += ', '

console.log s

 

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

(loop for i from 1 below 10 do

(princ i) (princ ", ")

finally (princ i))

 

or

 

(princ i)

(if (= i 10) (return))

 

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

 

(format t "~{~a~^, ~}" (loop for i from 1 to 10 collect i))

 

=== Using DO ===

(do ((i 1 (incf i))) ; Initialize to 1 and increment on every loop

((> i 10)) ; Break condition

(princ ", ") ; Printing the comma is jumped by the go statement

end) ; The tag

or

(do ; Not exactly separate statements for the number and the comma

((i 1 (incf i))) ; Initialize to 1 and increment on every loop

(princ i) ; Print number statement

(princ ", ")) ; Print comma statement

 

{{out}}

 

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

(string-delimiter "")

 

(string-join (range 1 11) ",")

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

 

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

io:format("~p\n",[N])

end.

 

=={{header|ERRE}}==

FOR I=1 TO 10 DO

PRINT(I;)

PRINT(", ";)

END FOR

 

=={{header|Euphoria}}==

for i = 1 to 10 do

printf(1, "%g", {i})

end if

end for

 

While, yes, use of <code>exit</code> would also work here, it is slightly faster to code it this way, if only the last iteration has something different.

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

Functional version that works for lists of any length

let rec print (lst : int list) =

match lst with

 

print [1..10]

 

=={{header|Factor}}==

[ [1,b] ] keep '[

[ number>string write ]

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

 

=={{header|Falcon}}==

formiddle

>> value

end

forlast: > value

 

{{out}}

 

=={{header|FALSE}}==

 

=={{header|Fantom}}==

 

class Main

{

}

}

 

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

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

 

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

 

=={{header|IDL}}==

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.

end.

 

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

The short-circuiting && is idiomatic to Julia - the second expression will only be evaluated if the first one is true.

for i = 1:10

print(i)

print(", ")

end

Output:

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

 

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

{def loops_N_plus_one_half

{lambda {:i :n}

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

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

 

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

Module Checkit {

\\ old type loop

}

Checkit

 

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

bundle Default {

class Hello {

}

}

 

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

Using a for-loop:

for N in {List.number 1 10 1} break:Break do

{System.printInfo N}

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

echo $i;

if ($i == 10)

echo ', ';

}

 

=={{header|PicoLisp}}==

(prin N)

(T (= N 10))

 

=={{header|Pike}}==

int main(){

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

}

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

do i = 1 to 10;

put edit (trim(i)) (a);

if i < 10 then put edit (', ') (a);

end;

 

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

true.</pre>

 

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

[print(str(i+1) + ", ",end='') if i < 9 else print(i+1) for i in range(10)]

 

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

(formerly Perl 6)

.print;

last when 10;

}

 

 

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

set i = 1

set result = ""

end while

echo result

 

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

 

=={{header|Ring}}==

for x = 1 to 10 see x if x=10 exit ok see ", " next see nl

 

=={{header|Ruby}}==

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

print i

print ", "

end

More idiomatic Ruby to obtain the same result is:

 

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

for i in 1...10 {

print(i, terminator: i == 10 ? "\n" : ", ")

}

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

$$ MODE TUSCRIPT

line=""

ENDLOOP

PRINT line

Output:

<pre>

 

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

echon i

if (i != 10)

echon ", "

endif

 

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>

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

</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();

}

}