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

 

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

PRINT

</syntaxhighlight>

 

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

 

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

}

 

<syntaxhighlight lang="easylang">

for i = 1 to 10

.

.

</syntaxhighlight>

 

 

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

}

</syntaxhighlight>

 

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

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

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

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

</syntaxhighlight>

 

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

</syntaxhighlight>

 

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

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

<syntaxhighlight lang="python">

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

</syntaxhighlight>

 

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

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

</syntaxhighlight>

 

=={{header|Ruby}}==

print ", "

end

More idiomatic Ruby to obtain the same result is:

<syntaxhighlight lang="ruby">

</syntaxhighlight>

 

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

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

}

}