Loops/For: Difference between revisions

{{trans|Python}}

 

L 1..i

print(‘*’, end' ‘’)

 

Pythonic solution:

 

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

;Basic - Algol style

The opcode BXH uses 3 registers, one for index, one for step and one for limit.

* Loops/For - BXH Algol 27/07/2015

LOOPFOR CSECT

YREGS

END LOOPFOR

{{out}}

<pre>

;Structured Macros

Structured and without BXH, only one register used by loop.

* Loops/For - struct 29/06/2016

LOOPFOR CSECT

YREGS

END LOOPFOR

{{out}}

Same as above

 

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

The following works with MS-DOS. Called as a subroutine (i.e. "call StarSub")

 

mov ah,02h ;needed to prime the interrupt command for printing to screen

jnz outer_loop

 

 

=={{header|8th}}==

This illustrates two kinds of 'for' loop. The first kind is "loop", which iterates from the low to the high value, and passes the current loop index as a parameter to the inner word. The second is 'times', which takes a count and repeats the word that many times.

 

( ( '* putc ) swap times cr ) 1 5 loop

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program loop64.s */

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

.include "../includeARM64.inc"

 

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

byte I,J

 

Od

 

 

=={{header|ActionScript}}==

for (var i:int = 1; i <= 5; i++) {

for (var j:int = 1; j <= i; j++)

trace(str);

str = "";

 

=={{header|Ada}}==

for J in 1..I loop

Put("*");

end loop;

New_Line;

 

=={{header|Agena}}==

Tested with Agena 2.9.5 Win32

for j to i do

write( "*" )

od;

print()

 

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

FOR I:=1 STEP 1 UNTIL 5 DO

BEGIN

OUTLINE

END

 

=={{header|ALGOL 68}}==

 

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

TO i DO

print("*")

OD;

print(new line)

{{out}}

<pre>

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

In Algol W, write starts a new line, writeon continues it.

for i := 1 until 5 do

begin

end j

end i

 

=={{header|ALGOL-M}}==

INTEGER I, J;

FOR I := 1 STEP 1 UNTIL 5 DO

WRITEON( "*" );

END;

{{out}}

<pre>*

=={{header|Alore}}==

 

for j in 0 to i

Write('*')

WriteLn()

end

 

=={{header|AmigaE}}==

DEF i, j

FOR i := 1 TO 5

WriteF('\n')

ENDFOR

 

=={{header|Apex}}==

String line = '';

 

for (String line : lines) {

System.debug(line);

 

=={{header|APL}}==

 

 

 

{{works with|Dyalog APL}}

 

 

{{Out}}

 

 

**

***

 

=={{header|AppleScript}}==

repeat with i from 1 to 5

repeat with j from 1 to i

set x to x & linefeed

end repeat

{{out}}

<pre>*

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program loop1.s */

bx lr /* return */

 

 

=={{header|Arturo}}==

loop 0..x 'y [

prints "*"

]

print ""

{{out}}

<pre>*

*****

******</pre>

 

=={{header|AutoHotkey}}==

Gui, Show ; Show the window

Loop, 5 ; loop 5 times

Output .= (A_Index = 5) ? "" : "`n" ; append a new line to the output if A_Index is not "5"

}

 

=={{header|Avail}}==

[

For each length from 1 to row do [Print: "*";];

Print: "\n";

Since the inner loop index is unneeded, it may be more natural to use the <code>From_to_do_</code> loop format:

[

From 1 to row do [Print: "*";];

Print: "\n";

 

=={{header|AWK}}==

 

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

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

print

}

 

=={{header|Axe}}==

In this example, the Axe code is nearly identical to the [[#TI-83_BASIC|TI-83 BASIC]] version. However, note the swapped order of the I and J in the Output() statement. Also, unlike TI-83 BASIC, Axe does not support an increment value other than 1.

For(I,1,5)

For(J,1,I)

Output(J,I,"*")

End

 

=={{header|Babel}}==

 

 

(star_triangle {

"\n" << }

->

 

{{out}}

The key operator here is 'iter' which gives the current iteration of the loop body it

resides in. When used with the 'times' operator, it generates a countdown.

 

=={{header|bash}}==

for i in {1..5}

do

echo

done

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

for j = 1 to i

print "*";

next j

print

 

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

 

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

for j = 1 to i

print "*";

print

next i

 

==={{header|BaCon}}===

FOR i = 1 TO 5

FOR j = 1 TO i

PRINT

NEXT

 

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

{{works with|BBC BASIC for Windows}}

FOR I% = 1 TO 5

FOR J% = 1 TO I%

PRINT

NEXT

 

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

20 : FOR J = 1 TO I

30 : PRINT "*";

40 : NEXT J

50 : PRINT

 

==={{header|Creative Basic}}===

OPENCONSOLE

 

 

END

 

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

20 FOR J = 1 TO I

30 PRINT "*";

50 PRINT

60 NEXT I

 

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

#APPTYPE CONSOLE

FOR dim i = 1 TO 5

PRINT

NEXT i

{{out}}

<pre>

 

==={{header|FUZE BASIC}}===

FOR k = 1 to n CYCLE

print "*";

PRINT

REPEAT

 

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

110 FOR J=1 TO I

120 PRINT "*";

130 NEXT

140 PRINT

 

==={{header|IWBASIC}}===

OPENCONSOLE

 

 

'Could also have been written the same way as the Creative Basic example, with no LOCATE command.

 

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

Unlike some BASICs, Liberty BASIC does not require that the counter variable be specified with 'next'.

for j = 1 to i

print "*";

next

print

 

 

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

For j = 1 To i

TextWindow.Write("*")

EndFor

TextWindow.WriteLine("")

 

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

Define i, j

For i=1 To 5

Print(#LFCR$+"Press ENTER to quit"): Input()

CloseConsole()

 

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

FOR j = 1 TO i

PRINT "*";

NEXT j

PRINT

 

==={{header|smart BASIC}}===

While some versions of BASIC allow for NEXT without a variable, smart BASIC requires the variable designation.

 

for m = 1 to n

print "*";

next m

print

 

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

FOR j = 1 TO i

PRINT "*";

PRINT

NEXT i

 

==={{header|Visual Basic}}===

'''Works with:''' VB6

For i = 0 To 4

For j = 0 To i

Next j

OutConsole.WriteLine

 

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

{{works with|Visual Basic .Net 2002}}

For y As Integer = 0 To x

Console.Write("*")

Next

Console.WriteLine()

 

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

for j = 1 to i

print "*";

print

next i

 

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

On the ZX Spectrum, we need line numbers:

 

20 FOR j = 1 TO i

30 PRINT "*";

40 NEXT j

50 PRINT

 

=={{header|Batch File}}==

SETLOCAL ENABLEDELAYEDEXPANSION

 

)

 

 

=={{header|bc}}==

for (j = 1; j <= i; j++) "*"

"

"

}

 

=={{header|BCPL}}==

 

let start() be

$( for j = 1 to i do wrch('**')

wrch('*N')

 

=={{header|Befunge}}==

| :-1<

 

=={{header|blz}}==

line = ""

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

end

print(line)

 

=={{header|Bracmat}}==

& whl

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

)

&

 

=={{header|Brainf***}}==

+++++[>++[>>+<<-]<-]<< place \n in cell 4

+++++[ set outer loop count

>[>>.<<-]>>>.<<< print line

<<-] end inner loop

 

=={{header|Brat}}==

1.to i, { j |

print "*"

}

print "\n"

 

=={{header|C}}==

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

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

putchar('*');

puts("");

 

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

 

class Program {

}

}

 

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

for(int i = 0; i < 5; ++i) {

for(int j = 0; j < i; ++j)

 

std::cout.put('\n');

 

=={{header|Ceylon}}==

for(i in 1..5) {

print("");

}

 

=={{header|Chapel}}==

for 1..i do write('*');

writeln();

 

=={{header|Chef}}==

 

 

This recipe prints a triangle of asterisks.

Pour contents of the mixing bowl into the baking dish.

 

 

=={{header|Clojure}}==

 

(print "*")

 

=={{header|CLU}}==

po: stream := stream$primary_output()

stream$putl(po, "")

end

 

=={{header|COBOL}}==

PROGRAM-ID. Display-Triangle.

 

GOBACK

.

 

=={{header|ColdFusion}}==

 

With tags:

<cfloop index = "j" from = "1" to = "#i#">

*

</cfloop>

< br />

With script:

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

{

writeOutput( "< br />" );

}

 

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

(loop for j from 1 upto i do

(write-char #\*))

or

(dotimes (j (+ i 1))

(write-char #\*))

or

((> i 5))

(do ((j 1 (+ j 1)))

((> j i))

(write-char #\*))

or

(iter

(for i from 1 to 5)

(for j from 1 to i)

(princ #\*))

 

=={{header|Coq}}==

 

Variable T : Type.

Variable body : nat -> T -> T.

)

0 5 nil.

 

=={{header|Cowgol}}==

 

var i: uint8 := 1;

print_nl();

i := i + 1;

 

=={{header|Crystal}}==

 

1.upto(5) do |i|

1.upto(i) do |j|

puts

end

 

Or another way, more succinctly put:

 

puts (1..5).map { |i| "*" * i }.join("\n")

 

=={{header|D}}==

 

void main() {

writeln();

}

{{out}}

<pre>*

 

=={{header|Dao}}==

for( j = 1 : i ) io.write( '*' )

io.writeln()

 

=={{header|Dart}}==

for (var i = 0; i < 5; i++)

for (var j = 0; j < i + 1; j++)

print("*");

print("\n");

 

=={{header|dc}}==

 

{{trans|bc}}

[*]P [print asterisk]sz

lj 1 + d sj [increment j, leave it on stack]sz

]sB

1 d si [i = 1, leave it on stack]sz

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Writeln;

end;

 

=={{header|DMS}}==

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

{

}

Result( "\n" )

 

=={{header|dodo0}}==

(

test(var) -> continue

)

| result

 

=={{header|Draco}}==

byte i,j;

for i from 1 upto 5 do

writeln()

od

{{out}}

<pre>*

 

=={{header|Dragon}}==

for (j = 0, j <= i, j++) {

show "*"

}

showln ""

 

=={{header|DWScript}}==

 

for i := 1 to 5 do begin

Print('*');

PrintLn('');

 

=={{header|Dyalect}}==

{{trans|Swift}}

 

for _ in 1..i {

print("*", terminator: "")

}

print()

 

Output:

=={{header|E}}==

 

for _ in 1..width {

print("*")

}

println()

 

This loop is a combination of <code>for ... in ...</code> which iterates over something and <code>a..b</code> which is a range object that is iteratable. (Also, writing <code>a..!b</code> excludes the value b.)

=={{header|EasyLang}}==

 

write "*"

.

print ""

 

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

 

Characters are encoded in five-bit form, with each code point producing a different character depending on whether the machine is in 'letter' or 'figure' mode: this is why it is necessary to output a 'figure shift' control character at the beginning of the job.

=====

[ 24 ] P0F [ used to clear a ]

{{out}}

<pre>+

 

=={{header|EGL}}==

for ( i int to 5 )

str = "";

end

SysLib.writeStdout(str);

 

=={{header|Ela}}==

 

 

loop m n | n < m = do

| else = do return ()

 

 

 

Output:

 

***

****

********

*********

 

=={{header|Elena}}==

public program()

{

{

console.writeLine()

}

{{out}}

<pre>

 

=={{header|Elixir}}==

def loops_for(n) do

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

end

 

 

one line (Comprehensions)

 

=={{header|Erlang}}==

-module(nested_loops).

-export([main/0, inner_loop/0]).

io:format("~n"),

inner_loop(N).

 

=={{header|ERRE}}==

FOR I=1 TO 5 DO

FOR J=1 TO I DO

PRINT

END FOR

 

=={{header|Euphoria}}==

 

for i = 1 to 5 do

for j = 1 to i do

puts(1, "\n") -- Same as "puts(1, {'\n'})"

end for

 

<code>puts()</code> is a function that takes two arguments; an <code>integer</code> and a <code>sequence</code>. Strings are simply <code>sequence</code>s; there is no string type.

 

=={{header|F_Sharp|F#}}==

[<EntryPoint>]

let main args =

printf "*"

printfn ""

 

=={{header|Factor}}==

 

=={{header|FALSE}}==

 

=={{header|Fantom}}==

Using for loops:

 

class ForLoops

{

}

}

 

Using range objects:

 

class ForLoops

{

}

}

 

=={{header|Fennel}}==

(for [j 1 i]

(io.write "*"))

(print))

 

=={{header|Fermat}}==

for i = 1 to 5 do for j = 1 to i do !'*'; od; !; od

 

=={{header|FOCAL}}==

When the program exits the outer loop, the control variable <tt>I</tt> is set to 4 + 1 = 5; we can therefore permit execution to fall through into the inner loop for one more iteration.

 

02.10 FOR J=1,I; TYPE "*"

{{out}}

<pre>

 

=={{header|Forth}}==

1+ 1 do

cr i 0 do [char] * emit loop

loop ;

One more:

: limit_example

15 1 do r> r@ dup rot >r drop \ Bring limit on stack

loop ;

\ Gforth and JSForth all work, SP-Forth brakes (different 'for' implementation?)

 

=={{header|Fortran}}==

{{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 (A, $)

C5001 FORMAT (A, ADVANCE='NO')

 

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

DO j = 1, i

WRITE(*, "(A)", ADVANCE="NO") "*"

END DO

WRITE(*,*)

 

Fortran 95 (and later) has also a loop structure that can be used only when the result is independent from real order of execution of the loop.

 

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

integer, dimension(10) :: v

 

 

But if one accepts that a do-loop can be expressed without the actual word "do" (or "for"), then

DO 1 I = 1,5

1 WRITE (6,*) ("*", J = 1,I)

END

That is a complete programme, though a more polite source file would have INTEGER I,J. It uses the old-style DO ''label'' etc. style of DO-loop to save on having to specify an END DO. The WRITE statement's output list is generated by an "implied" DO-loop having much of the form of DO J = 1,I and is indeed a proper loop. The output item is a text literal, which in earlier Fortran was unknown, however the result can still be achieved:

DO 1 I = 1,5

1 WRITE (6,2) (666, J = 1,I)

2 FORMAT(5I1)

END

This works because if a value cannot be fitted into its output field, the field is filled with asterisks. Which, is what is wanted! Just allow one digit for output (I1), and present a large integer.

 

=={{header|FreeBASIC}}==

 

For i As Integer = 1 To 5

Next

 

 

{{out}}

 

=={{header|Frink}}==

for n = 1 to 5

{

println[]

}

 

=={{header|Futhark}}==

inner loop.

 

fun main(n: int): [n]int =

loop (a = replicate n 0) = for i < n do

in a)

in a

 

=={{header|FutureBasic}}==

 

long i, j

next

 

 

=={{header|Gambas}}==

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

Dim i, j As Integer

 

Next

 

<pre>

*

 

=={{header|GAP}}==

for j in [1 .. i] do

Print("*");

# ***

# ****

 

=={{header|GML}}==

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

{

pattern += "#"

}

 

=={{header|Go}}==

 

import "fmt"

fmt.Printf("\n")

}

{{out}}

<pre>

=={{header|Groovy}}==

Solution:

for(j in (1..i)) {

print '*'

}

println ()

 

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

110 FOR J=1 TO I

120 PRINT "*";

140 PRINT

150 NEXT I

 

{{out}}

 

=={{header|Hack}}==

for($j = 0; $j <= $i; $j++) {

echo '*';

echo '\n';

 

=={{header|Haskell}}==

 

main = do

forM_ [1..i] $ \j -> do

putChar '*'

 

But it's more Haskellish to do this without loops:

 

 

 

Or, with a list comprehension:

 

 

Taking from an infinite stream of increasing length lines:

 

 

=={{header|Haxe}}==

 

for(j in 0...i) {

Sys.print('*');

}

Sys.println('');

 

=={{header|hexiscript}}==

for let j 1; j <= i; j++

print "*"

endfor

println ""

 

=={{header|HicEst}}==

DO j = 1, i

WRITE(APPend) "*"

ENDDO

WRITE() ' '

 

=={{header|HolyC}}==

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

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

Print("*");

Print("\n");

 

== Icon and Unicon ==

==={{header|Icon}}===

every i := 1 to 5 do {

every 1 to i do

write()

}

==={{header|Unicon}}===

The Icon solution works in Unicon.

 

=={{header|Inform 7}}==

repeat with N running from 1 to length:

say "*";

 

=={{header|J}}==

 

]\ '*****'

 

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

 

But you would almost never see J code like this.

 

=={{header|Java}}==

for (int j = 0; j <= i; j++) {

System.out.print("*");

}

System.out.println();

 

=={{header|JavaScript}}==

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

s = '';

s += '*';

document.write(s + '<br>');

 

 

or a simple range function which generates a range:

 

return i ? range(i - 1).concat(i) : [];

}

 

 

We could write something like:

 

 

range(5).forEach(

);

 

 

but it might be more natural in JavaScript, if we are going to use built-in Array functions, to simplify a little with '''Array.reduce()''', writing:

 

range(5).reduce(

function (a, n) {

}, ''

)

 

in which the inner ''n'' refers to the Array value visited at the next level out, and the triangle is returned as a single expression, rather than as a series of variable mutations.

Finally, in contexts where an expression composes better than a statement, the effect of a loop can often be expressed as a map.

 

range(5).map(function(a) {

return Array(a + 1).join('*');

}).join('\n')

 

=={{header|Jinja}}==

Variable usage inside a loop,

before version 2.10 :

{% for i in range(6) %}

{{ sum }}{% set sum = sum + i %}

{%- endfor %}""").render())

Since 2.10 :

{% for i in range(6) %}

{{ sum.value }}{% set sum.value = sum.value + i %}

{%- endfor %}""").render())

 

=={{header|jq}}==

def demo(m):

reduce range(0;m) as $i

 

# Variation of demo2 using an implicit inner loop:

'''Example using demo(6)'''

{{Out}}

=={{header|Jsish}}==

Code from Javascript entry.

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

s = '';

for (j = 0; j < i; j += 1) s += '*';

puts(s);

 

{{out}}

 

=={{header|Julia}}==

for i in 1:5

for j in 1:i

println()

end

 

{{out}}

 

=={{header|Klong}}==

:" x{p}:*y means repeat {p} x times starting at y "

 

 

{.p(x:^0c*)}'1+!5

 

=={{header|Kotlin}}==

(1..5).forEach {

(1..it).forEach { print('*') }

println()

}

 

=={{header|LabVIEW}}==

 

=={{header|Lambdatalk}}==

{def loops_for

{lambda {:i :n}

* * * *

* * * * *

 

=={{header|Lang5}}==

: nip swap drop ; : last -1 extract nip ;

: times

 

: concat "" join ;

 

=={{header|langur}}==

for .j = 0; .j <= .i; .j += 1 {

write "*"

}

writeln()

 

A for of loop iterates over keys (when used with an array, string, or hash) and a for in loop iterates over values.

 

for of .i {

write "*"

}

writeln()

 

Or, with one for loop...

 

=={{header|Lasso}}==

loop(loop_count) => {^ '*' ^}

'\r'

 

=={{header|LC3 Assembly}}==

 

AND R1,R1,0

LF .FILL 0x0A

 

Output:

<pre>*

****

*****</pre>

 

=={{header|LIL}}==

In LIL '''for''' takes a before loop code block for init, a conditional expression (true to enter loop step, false to exit loop), an after each loop step code block for value reassignment, followed by the code for the loop.

 

for {set j 1} {$j <= $i} {inc j} {

write "*"

}

print

 

{{out}}

 

=={{header|Lingo}}==

str = ""

repeat with j = 1 to i

end repeat

put str

 

=={{header|Lisaac}}==

1.to i do { dummy : INTEGER;

'*'.print;

};

'\n'.print;

 

=={{header|LiveCode}}==

repeat for 5 times

add 1 to n

end repeat

put return

 

=={{header|Logo}}==

 

=={{header|Lua}}==

for i=1,5 do

for j=1,i do

io.write("\n")

end

single loop

print(string.rep("*", i))

or

print(("*"):rep(i))

 

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

By default there For loops always perform on execution of block. If end value is smaller than fist value, then step adjust to that direction. When first value is equal to second value then if we declare step negative end value after execution of block became start value minus absolute step, or if step is positive, became start value plus step. We can use a switch for interpreter to change IF's STEP to act as BASIC's, and sign of step always used, and there is situations where block can't executed.

 

For i=1 to 5

For j=1 to i

}

Print "End2"

 

=={{header|M4}}==

`ifelse($#,0,``$0'',

`ifelse(eval($2<=$3),1,

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

`*')

 

=={{header|make}}==

{{works with|BSD make}}

{{libheader|jot}}

 

ILIST != jot 5

 

. endfor

 

=={{header|Maple}}==

*

**

***

****

 

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

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

string="";

For[j=1,j<=i,j++,string=string<>"*"];

Print[string]

 

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

output = [];

for j = (1:i)

end

disp(output);

 

Vectorized version:

 

disp(repmat('*',1,i));

 

=={{header|Maxima}}==

 

s: "",

thru i do s: sconcat(s, "*"),

print(s)

 

=={{header|MAXScript}}==

(

line = ""

)

format "%\n" line

 

=={{header|Mercury}}==

:- interface.

 

 

inner_loop_body(_, !IO) :-

 

=={{header|MiniScript}}==

Literal interpretation of the task is somewhat complicated by the fact that the standard implementation of <code>print</code> in MiniScript adds a line break:

s = ""

for j in range(1, i)

end for

print s

 

{{out}}

However, it is worth noting that MiniScript's string replication operator (*) makes a more natural solution possible:

 

print "*" * i

 

(Output same as above.)

 

=={{header|Modula-2}}==

IMPORT InOut;

 

InOut.WriteLn

END

 

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

 

IMPORT IO;

IO.Put("\n");

END;

 

=={{header|MOO}}==

s = "";

for j in [1..i]

endfor

player:tell(s);

 

=={{header|Morfa}}==

import morfa.base;

 

println("");

}

 

=={{header|MUMPS}}==

=== Routine ===

NEW I,J

FOR I=1:1:5 DO

..WRITE "*"

.WRITE !

{{out}}

<pre>

=== One line ===

The if statement has to follow the write, or else the if statement would control the write (5 lines with one asterisk each).

 

=={{header|Nanoquery}}==

for ($j = 0) ($j < $i) ($j = $j+1)

print "*"

end for

println

 

=={{header|Nemerle}}==

{

for (int j = 0; j <= i; j++)

}

WriteLine();

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols nobinary

 

say

end i_

 

=={{header|NewLISP}}==

(for (i 1 5)

(for(j 1 i)

(print "*"))

(print "\n"))

 

=={{header|Nim}}==

for j in 1..i:

stdout.write("*")

 

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

20 FOR J=1 TO I

30 PRINT "*";

40 NEXT

50 PRINT

 

=={{header|Oberon-2}}==

Works with oo2c Version 2

MODULE LoopFor;

IMPORT

END

END LoopFor.

 

=={{header|Objeck}}==

bundle Default {

class For {

}

}

 

=={{header|OCaml}}==

for j = 1 to i do

print_string "*"

done;

print_newline ()

 

=={{header|Octave}}==

for j = 0:1:i

printf("*");

endfor

printf("\n");

 

=={{header|Oforth}}==

| i j |

n loop: i [

i loop: j [ "*" print ]

 

=={{header|Onyx}}==

Using repeat inside the for loop instead of nesting another for loop is shorter and more efficient.

 

=={{header|Order}}==

 

ORDER_PP(

8space)),

1, 6)

(Order cannot print newlines, so this example just uses a space.)

 

=={{header|Oz}}==

for _ in 1..I do

{System.printInfo "*"}

end

{System.showInfo ""}

Note: we don't use the inner loop variable, so we prefer not to give it a name.

 

=={{header|Panoramic}}==

dim x,y

 

 

next x

 

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

 

=={{header|Pascal}}==

 

var

writeln

end

 

=={{header|Perl}}==

for(my $y = 1; $y <= $x; $y++) {

print "*";

}

print "\n";

foreach (1..$_) {

print '*';

}

print "\n";

 

However, if we lift the constraint of two loops the code will be simpler:

 

 

or equivalently

 

 

=={{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;">5</span> <span style="color: #008080;">do</span>

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

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

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

 

=={{header|PHP}}==

for ($j = 1; $j <= $i; $j++) {

echo '*';

}

echo "\n";

or

foreach (range(1, $i) as $j) {

echo '*';

}

echo "\n";

or

 

=={{header|Picat}}==

N = 5,

foreach(I in 1..N)

end,

nl

 

 

=={{header|PicoLisp}}==

(do N (prin "*"))

 

=={{header|Pike}}==

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

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

write("\n");

}

 

=={{header|PILOT}}==

Core PILOT does not offer any way of printing without a newline, so in the inner loop we concatenate another star onto the string variable <code>$stars</code> each time round and then print it in the outer loop.

*OuterLoop

C :j = 0

C :i = i + 1

J ( i < 6 ) :*OuterLoop

 

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

Basic version:

do j = 1 to i;

put edit ('*') (a);

end;

put skip;

Advanced version:

put skip edit (('*' do j = 1 to i)) (a);

Due to the new line requirement a mono line version is not possible

 

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

Plain English doesn't allow the direct nesting of loops. Instead, you are encouraged to make one routine for each loop and let the routine headers describe what the loops are doing.

Start up.

Write a triangle of asterisks on the console given 5.

If a counter is past the size, exit.

Write a row of asterisks on the console given the counter.

 

=={{header|Pop11}}==

for i from 1 to 5 do

for j from 1 to i do

endfor;

printf('\n')

 

=={{header|PowerShell}}==

for ($j = 1; $j -le $i; $j++) {

Write-Host -NoNewline *

}

Write-Host

Alternatively the same can be achieved with a slightly different way by using the range operator along with the <code>ForEach-Object</code> cmdlet:

1..$_ | ForEach-Object {

Write-Host -NoNewline *

}

Write-Host

while the inner loop wouldn't strictly be necessary and can be replaced with simply <code>"*" * $_</code>.

 

=={{header|Processing}}==

 

for ( int i=20; i<=100; i+=20 )

for ( int j=10; j<=i; j+=20 )

 

=={{header|Prolog}}==

Prolog has a built in iterator, between(Lo,Hi,I) which binds the value of I to successive values from Lo to Hi. This is the closest thing Prolog has to a 'for' loop.

between(1,5,I), nl, between(1,I,_J),

write('*'), fail.

<pre>?- example.

 

 

=={{header|Python}}==

for i in xrange(5):

for j in xrange(i+1):

sys.stdout.write("*")

Note that we have a constraint to use two for loops, which leads to non-idiomatic Python. If that constraint is dropped we can use the following, more idiomatic Python solution:

or

 

=={{header|QB64}}==

''CBTJD'': 2020/03/14

FOR n = 1 TO c

PRINT "*";

NEXT

PRINT

 

=={{header|Quackery}}==

{{Out}}

<pre>*

 

=={{header|R}}==

s <- ""

for(j in 0:i) {

}

print(s)

 

=={{header|Racket}}==

 

=={{header|Raku}}==

{{works with|Rakudo|#22 "Thousand Oaks"}}

 

 

for 0..$_ {

print "\n";

 

 

or using only one for loop:

 

 

or without using any loops at all:

 

 

=={{header|REBOL}}==

 

repeat i 5 [

loop i [prin "*"]

print ""

 

=={{header|Red}}==

 

repeat i 5 [

loop i [prin "*"]

prin newline

 

=={{header|ReScript}}==

for i in 1 to 5 {

for _ in 1 to i {

s := Js.String2.concat(s.contents, "\n")

}

{{output}}

<pre>

 

=={{header|Retro}}==

 

=={{header|REXX}}==

===using concatenation===

 

do j=1 for 5 /*this is the same as: do j=1 to 5 */

end /*k*/

say $ /*display character string being built.*/

{{out|output|:}}

<pre>

 

===using abutment===

 

do j=1 for 5 /*this is the same as: do j=1 to 5 */

end /*k*/

say $ /*display character string being built.*/

{{out|output|text=&nbsp; is identical to the 1^st REXX version.}} <br><br>

 

=={{header|Ring}}==

can be done in just one line:

for i = 1 to 5 for x = 1 to i see "*" next see nl next

or multiple line

for i = 1 to 5

for x = 1 to i

see nl

next

 

=={{header|Ruby}}==

One can write a <tt>for</tt> loop as <tt>for i in 1..5; ...end</tt> or as <tt>for i in 1..5 do ... end</tt> or as <tt>(1..5).each do |i| ... end</tt>. All three forms call <tt>Range#each</tt> to iterate <tt>1..5</tt>.

|-

| style="vertical-align: top;" |

for j in 1..i

print "*"

end

puts

| style="vertical-align: top;" |

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

print "*"

end

puts

|}

 

|-

| style="vertical-align: top;" |

1.upto(i) do |j|

print "*"

end

puts

| style="vertical-align: top;" |

# i goes from 0 to 4

(i+1).times do

end

puts

| style="vertical-align: top;" |

loop do

j = 1

puts

break if (i += 1) > 5

|}

 

Or we can use String#* as the inner loop, and Enumerable#map as the outer loop. This shrinks the program to one line.

 

 

=={{header|Rust}}==

The compiler warns when you create an unused variable; here we use _ to avoid this effect.

for i in 0..5 {

for _ in 0..=i {

println!();

}

 

=={{header|Salmon}}==

{

iterate (y; [0...x])

print("*");;

print("\n");

 

or

 

{

for (y; 0; y <= x)

print("*");;

print("\n");

 

=={{header|SAS}}==

length a $5;

do n=1 to 5;

put a;

end;

 

=={{header|Sather}}==

Sather allows the definition of new iterators. Here's we define <code>for!</code> so that it resembles the known <code>for</code> in other languages, even though the <code>upto!</code> built-in can be used.

 

-- from, to, step

for!(once init:INT, once to:INT, once inc:INT):INT is

end;

end;

 

=={{header|Scala}}==

for (j <- 1 to i)

print("*")

println()

 

=={{header|Scheme}}==

((> i 5))

(do ((j 1 (+ j 1)))

((> j i))

(display "*"))

 

=={{header|Scilab}}==

{{works with|Scilab|5.5.1}}

s=""

for j=1:i

end

printf("%s\n",s)

{{out}}

<pre>*

 

=={{header|Seed7}}==

 

=={{header|SETL}}==

for j in {1..i} loop

nprint( '*' );

end loop;

print; -- new line

 

=={{header|Sidef}}==

'''for(;;)''' loop:

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

print '*'

}

print "\n"

 

'''for([])''' loop:

for (1..i) { print '*' }

print "\n"

 

'''for-in''' loop:

for j in (1..i) { print '*' }

print "\n"

 

Idiomatic:

i.times { print '*' }

print "\n"

 

=={{header|Simula}}==

{{works with|SIMULA-67}}

integer i,j;

for i:=1 step 1 until 5 do

end

end

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

aNumber timesRepeat: [ '*' display ].

Character nl display.

or:

1 to: row do: [:col | '*' display ].

(only for demonstration of nested for-loops; as the column is not needed, the first solution is probably clearer).

 

However, streams already have some builtin repetition mechanism, so a programmer might write:

{{works with|Smalltalk/X}}

Stdout next: n put: $*; cr

 

=={{header|SNOBOL4}}==

A slightly longer, "mundane" version

 

inner = outer; stars = ""

il stars = ?gt(inner,0) stars "*" :f(disp)

inner = inner - 1 :(il)

disp output = stars; :(ol)

 

The "real SNOBOL4" starts here:

inner t = t ?(b = (gt(b,0) b - 1)) "*" :s(inner)

t span("*") . terminal = :(outer)

 

one "loop" only:

a a len(x = x + 1) . output :s(a)

 

... or just (courtesy of GEP2):

{{works with|SNOBOL4|which defaults to anchored mode}}

 

=={{header|SNUSP}}==

 

=={{header|Sparkling}}==

for (var col = 1; col <= row; col++) {

printf("*");

 

print();

 

=={{header|Spin}}==

{{works with|HomeSpun}}

{{works with|OpenSpin}}

_clkmode = xtal1 + pll16x

_clkfreq = 80_000_000

waitcnt(_clkfreq + cnt)

ser.stop

{{out}}

<pre>

 

=={{header|SPL}}==

> j, 1..i

#.output("*",#.rs)

<

#.output()

 

=={{header|Stata}}==

 

local s ""

forvalues i=1/`n' {

}

display "`s'"

 

=== Mata ===

for (j=1; j<=i; j++) printf("*")

printf("\n")

 

=={{header|Suneido}}==

{

str = ''

str $= '*'

Print(str)

 

=={{header|Swift}}==

for _ in 1...i {

print("*", terminator: "")

}

print()

{{out}}

<pre>

=={{header|Tailspin}}==

Tailspin uses streams of values within streams of values rather than loops.

1..5 -> '$:1..$ -> '*';

' -> !OUT::write

{{out}}

<pre>

 

=={{header|Tcl}}==

for {set i 1} {$i <= $lines} {incr i} {

puts -nonewline "*"

}

puts ""

Note that it would be more normal to produce this output with:

puts [string repeat "*" $i]

 

It bears noting that the three parts of the for loop do not have to consist of "initialize variable", "test value of variable" and "increment variable". This is a common way to think of it as it resembles the "for" loop in other languages, but many other things make sense. For example this for-loop will read a file line-by-line:

 

for { set io [open test.txt r] } { ![eof $io] } { gets $io line } {

if { $line != "" } { ...do something here... }

 

(This is a somewhat awkward example; just to show what is possible)

 

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

ClrIO

For i, 1, 5

Output i*8, j*6, "*"

EndFor

 

=={{header|TorqueScript}}==

 

{

for(%x = %i; %x < 5; %x++)

echo(%string);

}

 

=={{header|TransFORTH}}==

1 + 1 DO

I 0 DO

PRINT " * " LOOP

CR LOOP ;

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

m=""

PRINT m

ENDLOOP

{{out}}

<pre>

 

=={{header|TypeScript}}==

let line: string = ""

for(let j: number = 0; j <= i; ++j) {

console.log(line)

}

 

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

 

{{works with|Bourne Shell}}

# Using a while control construct to emulate a for loop

 

echo

l=`expr "$l" + 1` # Increment the outer counter

 

The [[Bourne Shell]] has a for loop, but it requires a list of words to iterate.

{{works with|Bourne Shell}}

{{libheader|jot}}

for j in `jot $i`; do

printf \*

done

echo

 

Bash has <tt>for</tt> loops that act like C. These loops are very good for this task.

 

{{works with|Bourne Again SHell|3}}

for (( y=1; y<=$x; y=$y+1 )); do

echo -n '*'

done

echo ""

 

==={{header|C Shell}}===

{{libheader|jot}}

foreach j (`jot $i`)

echo -n \*

end

echo ""

 

 

=={{header|UnixPipes}}==

[ $n -gt 5 ] && exit 0;

yes \* | head -n $n | xargs -n $n echo

 

=={{header|Ursa}}==

# for loop

#

end for

out endl console

 

=={{header|Vala}}==

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

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

}

return 0;

 

=={{header|VBA}}==

Sub LoopEx()

Dim i As Long, j As Long, s As String

Debug.Print s

Next

 

=={{header|VBScript}}==

Dim i, j, s

For i = 1 To 5

Next

WScript.Echo s

 

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

for (#2 = 1; #2 <= #1; #2++) {

Type_Char('*')

}

Type_Newline

 

 

=={{header|Verilog}}==

module main;

integer i, j;

end

endmodule

 

for i in 1..6 {

for _ in 1..i+1 {

print("\n")

}

{{out}}

<pre>

 

=={{header|Wart}}==

for j 0 (j < i) ++j

pr "*"

 

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

print 1 "" ensures the end of program text is separate from the asterisk characters.

print 1 ""

for x=0 to y

next

next

 

=={{header|Wren}}==

for (j in 1..i) System.write("*")

System.print()

 

{{out}}

=={{header|x86 Assembly}}==

This subroutine uses only the original 16-bit 8086 instruction set; it is written for DOS, but could be adapted to run under other operating systems.

 

outerloop: mov cx, bx ; inner loop counter

jne outerloop

 

 

=={{header|XBasic}}==

{{works with|Windows XBasic}}

PROGRAM "for"

 

END FUNCTION

END PROGRAM

 

=={{header|XBS}}==

const maxIters = 5;

for(i=1;maxIters;1){

}

log(str);

{{out}}

<pre>*

=={{header|XLISP}}==

The equivalent of other languages' <tt>FOR</tt> or <tt>DO</tt> loops can be written using <tt>DO</tt>:

(DO ((J 0 (+ J 1))) ((= J I))

(DISPLAY "*"))

{{out}}

<pre>*

 

=={{header|XPL0}}==

int I, J;

for I:= 1 to 5 do

ChOut(0, ^*);

CrLf(0);

 

=={{header|Z80 Assembly}}==

For the Amstrad CPC (should work with e.g. the built-in assembler in JavaCPC; use <tt>call &4000</tt> to start from BASIC):

wr_char equ &bb5a ; write ASCII character in register A to screen

; (jumps into CPC ROM)

pop de

pop bc

 

=={{header|zkl}}==

foreach j in (i){print("*")}

println();

{{out}}

<pre>

*****

</pre>