I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Loops/For

Loops/For
You are encouraged to solve this task according to the task description, using any language you may know.

For”   loops are used to make some block of code be iterated a number of times, setting a variable or parameter to a monotonically increasing integer value for each execution of the block of code.

Common extensions of this allow other counting patterns or iterating over abstract structures other than the integers.

Task

Show how two loops may be nested within each other, with the number of iterations performed by the inner for loop being controlled by the outer for loop.

Specifically print out the following pattern by using one for loop nested in another:

```*
**
***
****
*****```

Related tasks

Reference

## 11l

Translation of: Python
`L(i) 1..5   L 1..i      print(‘*’, end' ‘’)   print()`

Pythonic solution:

`L(i) 1..5   print(‘*’ * i)`

## 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/2015LOOPFOR  CSECT         USING  LOOPFORC,R12         LR     R12,R15            set base registerBEGIN    LA     R2,0               from 1 (from-step=0)         LA     R4,1               step 1         LA     R5,5               to 5LOOPI    BXH    R2,R4,ELOOPI       for i=1 to 5  (R2=i)         LA     R8,BUFFER-1          ipx=-1         LA     R3,0                 from 1 (from-step=0)         LA     R6,1                 step 1         LR     R7,R2                to iLOOPJ    BXH    R3,R6,ELOOPJ         for j:=1 to i  (R3=j)         LA     R8,1(R8)               ipx=ipx+1         MVI    0(R8),C'*'             buffer(ipx)='*'         B      LOOPJ                next jELOOPJ   XPRNT  BUFFER,L'BUFFER      print buffer         B      LOOPI              next iELOOPI   BR     R14                return to callerBUFFER   DC     CL80' '            buffer         YREGS           END    LOOPFOR `
Output:
```*
**
***
****
*****
```
Structured Macros

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

` *        Loops/For - struct        29/06/2016LOOPFOR  CSECT         USING  LOOPFORC,R12         LR     R12,R15            set base register         LA     R2,1               from 1         DO WHILE=(CH,R2,LE,=H'5') for i=1 to 5  (R2=i)           LA     R8,BUFFER-1        ipx=-1           LA     R3,1               from 1           DO WHILE=(CR,R3,LE,R2)    for j:=1 to i  (R3=j)             LA     R8,1(R8)           ipx=ipx+1             MVI    0(R8),C'*'         buffer(ipx)='*'             LA     R3,1(R3)           j=j+1  (step)           ENDDO  ,                  next j           XPRNT  BUFFER,L'BUFFER    print buffer           LA     R2,1(R2)           i=i+1  (step)         ENDDO  ,                  next i         BR     R14                return to callerBUFFER   DC     CL80' '            buffer         YREGS         END    LOOPFOR `
Output:

Same as above

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

## AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits
` /* ARM assembly AARCH64 Raspberry PI 3B *//*  program loop64.s   */ /*******************************************//* Constantes file                         *//*******************************************//* for this file see task include a file in language AArch64 assembly*/.include "../includeConstantesARM64.inc"/*******************************************//* Initialized data                        *//*******************************************/.dataszMessX: .asciz "X"szCarriageReturn:  .asciz "\n"/*******************************************//* UnInitialized data                      *//*******************************************/.bss /*******************************************//*  code section                           *//*******************************************/.text.global main main:                     // entry of program     mov x2,0              // counter loop 11:                        // loop start 1    mov x1,0              // counter loop 22:                        // loop start 2    ldr x0,qAdrszMessX    bl affichageMess    add x1,x1,1           // x1 + 1    cmp x1,x2             // compare x1 x2    ble 2b                // loop label 2 before    ldr x0,qAdrszCarriageReturn       bl affichageMess    add x2,x2,1           // x2 + 1    cmp x2,#5             // for five loop    blt 1b                // loop label 1 before  100:                      // standard end of the program */    mov x0,0              // return code    mov x8,EXIT           // request to exit program    svc 0                 // perform the system call qAdrszMessX:           .quad szMessXqAdrszCarriageReturn:  .quad  szCarriageReturn/********************************************************//*        File Include fonctions                        *//********************************************************//* for this file see task include a file in language AArch64 assembly */.include "../includeARM64.inc" `

## ActionScript

`var str:String = "";for (var i:int = 1; i <= 5; i++) {	for (var j:int = 1; j <= i; j++)		str += "*";	trace(str);	str = "";}`

## Ada

`for I in 1..5 loop   for J in 1..I loop      Put("*");   end loop;   New_Line;end loop;`

## Agena

Tested with Agena 2.9.5 Win32

`for i to 5 do    for j to i do        write( "*" )    od;    print()od`

## ALGOL 60

`INTEGER I,J;FOR I:=1 STEP 1 UNTIL 5 DOBEGIN    FOR J:=1 STEP 1 UNTIL I DO      OUTTEXT("*");   OUTLINEEND `

## ALGOL 68

Works with: ALGOL 68 version Revision 1 - no extensions to language used
Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny
Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8-8d
`FOR i TO 5 DO   TO i DO      print("*")   OD;  print(new line)OD`
Output:
```*
**
***
****
*****
```

## ALGOL W

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

`begin    for i := 1 until 5 do    begin        write( "*" );        for j := 2 until i do        begin            writeon( "*" )        end j    end iend.`

## ALGOL-M

`BEGIN    INTEGER I, J;    FOR I := 1 STEP 1 UNTIL 5 DO    BEGIN        WRITE( "" );        FOR J := 1 STEP 1 UNTIL I DO            WRITEON( "*" );    END;END`
Output:
```*
**
***
****
*****```

## Alore

`for i in 0 to 6  for j in 0 to i      Write('*')  end  WriteLn()end `

## AmigaE

`PROC main()  DEF i, j  FOR i := 1 TO 5    FOR j := 1 TO i DO WriteF('*')    WriteF('\n')  ENDFORENDPROC`

## Apex

`for (Integer i = 0; i < 5; i++) {    String line = '';     for (Integer j = 0; j < i; j++) {        line += '*';    }     System.debug(line);} List<String> lines = new List<String> {    '*',    '**',    '***',    '****',    '*****'}; for (String line : lines) {    System.debug(line);}`

## AppleScript

`set x to returnrepeat with i from 1 to 5	repeat with j from 1 to i		set x to x & "*"	end repeat	set x to x & returnend repeatreturn x`
Output:
```"

" ```

## ARM Assembly

Works with: as version Raspberry Pi
` /* ARM assembly Raspberry PI  *//*  program loop1.s   */ /* Constantes    */.equ STDOUT, 1     @ Linux output console.equ EXIT,   1     @ Linux syscall.equ WRITE,  4     @ Linux syscall/* Initialized data */.dataszMessX: .asciz "X"szCarriageReturn:  .asciz "\n" /* UnInitialized data */.bss  /*  code section */.text.global main main:                /* entry of program  */    push {fp,lr}    /* saves 2 registers */     mov r2,#0       @ counter loop 11:       @ loop start 1    mov r1,#0        @ counter loop 22:       @ loop start 2    ldr r0,iAdrszMessX    bl affichageMess    add r1,#1       @ r1 + 1    cmp r1,r2       @ compare r1 r2    ble 2b        @ loop label 2 before    ldr r0,iAdrszCarriageReturn       bl affichageMess    add r2,#1       @ r2 + 1    cmp r2,#5       @ for five loop    blt 1b         @ loop label 1 before  100:   /* standard end of the program */    mov r0, #0                  @ return code    pop {fp,lr}                 @restaur 2 registers    mov r7, #EXIT              @ request to exit program    swi 0                       @ perform the system call iAdrszMessX:  .int szMessXiAdrszCarriageReturn:  .int  szCarriageReturn/******************************************************************//*     display text with size calculation                         */ /******************************************************************//* r0 contains the address of the message */affichageMess:    push {fp,lr}    			/* save  registres */     push {r0,r1,r2,r7}    		/* save others registers */    mov r2,#0   				/* counter length */1:      	/* loop length calculation */    ldrb r1,[r0,r2]  			/* read octet start position + index */    cmp r1,#0       			/* if 0 its over */    addne r2,r2,#1   			/* else add 1 in the length */    bne 1b          			/* and loop */                                /* so here r2 contains the length of the message */    mov r1,r0        			/* address message in r1 */    mov r0,#STDOUT      		/* code to write to the standard output Linux */    mov r7, #WRITE             /* code call system "write" */    swi #0                      /* call systeme */    pop {r0,r1,r2,r7}     		/* restaur others registers */    pop {fp,lr}    				/* restaur des  2 registres */     bx lr	        			/* return  */  `

## Arturo

`loop 0..5 'x [	loop 0..x 'y [		prints "*"	]	print ""]`
Output:
```*
**
***
****
*****
******```

## AutoHotkey

`Gui, Add, Edit, vOutput r5 w100 -VScroll ; Create an Edit-ControlGui, Show ; Show the windowLoop, 5 ; loop 5 times{  Loop, %A_Index% ; A_Index contains the Index of the current loop  {    output .= "*" ; append an "*" to the output var    GuiControl, , Output, %Output% ; update the Edit-Control with the new content    Sleep, 500 ; wait some(500ms) time, [just to show off]  }  Output .= (A_Index = 5) ? "" : "`n" ; append a new line to the output if A_Index is not "5"}Return ; End of auto-execution section`

## Avail

`For each row from 1 to 5 do[    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 `From_to_do_` loop format:

`For each row from 1 to 5 do[    From 1 to row do [Print: "*";];    Print: "\n";];`

## AWK

`BEGIN {  for(i=1; i < 6; i++) {    for(j=1; j <= i; j++ ) {      printf "*"    }    print  }}`

## Axe

In this example, the Axe code is nearly identical to the 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.

`ClrHomeFor(I,1,5)For(J,1,I)Output(J,I,"*")EndEnd`

## Babel

`((main { 10 star_triangle ! }) (star_triangle {     dup    <-     { dup { "*" << } <->             iter - 1 +         times         "\n" << }     ->     times }))`
Output:
```*
**
***
****
*****
******
*******
********
*********
**********```

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.

## bash

` for i in {1..5}do  for ((j=1; j<=i; j++));  do    echo -n "*"  done  echodone `

## BASIC

Works with: QuickBasic version 4.5
`FOR i = 1 TO 5   FOR j = 1 TO i      PRINT "*";   NEXT j   PRINTNEXT i`

### Applesoft BASIC

`FOR I = 1 TO 5 : FOR J = 1 TO I : PRINT "*"; : NEXT J : PRINT : NEXT`

### BASIC256

`for i = 1 to 5	for j = 1 to i		print "*";	next j	printnext iend`

### BaCon

` FOR i = 1 TO 5    FOR j = 1 TO i        PRINT "*"    NEXT    PRINTNEXT `

### BBC BASIC

`       FOR I% = 1 TO 5        FOR J% = 1 TO I%          PRINT"*";        NEXT        PRINT      NEXT `

### Commodore BASIC

`10 FOR I = 1 TO 520 FOR J = 1 TO I30 PRINT "*";40 NEXT50 PRINT60 NEXT`

### Creative Basic

` OPENCONSOLE FOR X=1 TO 5 	FOR Y=1 TO X             PRINT"*",:'No line feed or carriage return after printing. 	NEXT Y PRINT NEXT X PRINT:PRINT"Press any key to end." DO:UNTIL INKEY\$<>"" CLOSECONSOLE END `

### GW-BASIC

`10 FOR I = 1 TO 520 FOR J = 1 TO I30 PRINT "*";40 NEXT J50 PRINT60 NEXT I `

### FBSL

` #APPTYPE CONSOLEFOR DIM i = 1 TO 5    FOR DIM j = 1 TO i        PRINT "*";     NEXT j       PRINTNEXT iPause`
Output:
```*
**
***
****
*****
Press any key to continue...```

### FUZE BASIC

`FOR n = 1 TO 5 CYCLE    FOR k = 1 TO n CYCLE        PRINT "*";    REPEAT    PRINTREPEATEND`

### IS-BASIC

`100 FOR I=1 TO 5110   FOR J=1 TO I120     PRINT "*";130   NEXT140   PRINT150 NEXT`

### IWBASIC

` OPENCONSOLE FOR X=1 TO 5     FOR Y=1 TO X     LOCATE X,Y:PRINT"*"     NEXT Y NEXT X PRINT CLOSECONSOLE END 'Could also have been written the same way as the Creative Basic example, with no LOCATE command. `

### Liberty BASIC

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

`for i = 1 to 5    for j = 1 to i        print "*";    next    printnext `

### Microsoft Small Basic

`For i = 1 To 5   For j = 1 To i    TextWindow.Write("*")  EndFor  TextWindow.WriteLine("")EndFor`

### PureBasic

`If OpenConsole()  Define i, j  For i=1 To 5    For j=1 To i      Print("*")    Next j    PrintN("")  Next i  Print(#LFCR\$+"Press ENTER to quit"): Input()  CloseConsole()EndIf`

### Run BASIC

` FOR i = 1 TO 5   FOR j = 1 TO i      PRINT "*";   NEXT j   PRINTNEXT i `

### smart BASIC

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

`FOR n = 1 TO 5    FOR m = 1 TO n        PRINT "*";    NEXT m    PRINTNEXT n`

### Visual Basic

Works with: VB6

`Public OutConsole As Scripting.TextStreamFor i = 0 To 4    For j = 0 To i        OutConsole.Write "*"    Next j     OutConsole.WriteLineNext i`

### Visual Basic .NET

`For x As Integer = 0 To 4    For y As Integer = 0 To x        Console.Write("*")    Next    Console.WriteLine()Next`

### Yabasic

`for i = 1 to 5    for j = 1 to i        print "*";    next j    printnext iend`

### ZX Spectrum Basic

On the ZX Spectrum, we need line numbers:

` 10 FOR i = 1 TO 520 FOR j = 1 TO i30 PRINT "*";40 NEXT j50 PRINT60 NEXT i `

## Batch File

`@ECHO OFFSETLOCAL ENABLEDELAYEDEXPANSION for /l %%i in (1,1,5) do (    SET line=    for /l %%j in (1,1,%%i) do (        SET line=!line!*    )    ECHO !line!) ENDLOCAL`

## bc

`for (i = 1; i <= 5; i++) {	for (j = 1; j <= i; j++) "*"	""}quit`

## Befunge

`1>:5`#@_:>"*",v         | :-1< ^+1,+5+5<`

## blz

`for i = 1; i <= 5; i++    line = ""    for (j = 1; j <= i; j++)        line = line + "*"    end    print(line)end`

## Bracmat

`  0:?i&   whl  ' ( !i+1:~>5:?i    & 0:?k    & whl'(!k+1:~>!i:?k&put\$"*")    & put\$\n    )&);`

## Brainf***

`>>+++++++[>++++++[>+<-]<-]       place * in cell 3+++++[>++[>>+<<-]<-]<<           place \n in cell 4+++++[                           set outer loop count[>+                              increment inner counter>[-]>[-]<<[->+>+<<]>>[-<<+>>]<<  copy inner counter>[>>.<<-]>>>.<<<                 print line<<-]                             end inner loop]                                end outer loop`

## Brat

`1.to 5, { i |  1.to i, { j |    print "*"  }  print "\n"}`

## C

`int i, j;for (i = 1; i <= 5; i++) {  for (j = 1; j <= i; j++)    putchar('*');  puts("");}`

## C#

`using System; class Program {    static void Main(string[] args)    {        for (int i = 0; i < 5; i++)        {            for (int j = 0; j <= i; j++)            {                Console.Write("*");            }            Console.WriteLine();        }    }}`

## C++

` for(int i = 0; i < 5; ++i) {  for(int j = 0; j < i; ++j)    std::cout.put('*');   std::cout.put('\n');}`

## Ceylon

`shared void run() { 	for(i in 1..5) {		for(j in 1..i) {			process.write("*");		}		print("");	}}`

## Chapel

`for i in 1..5 {        for 1..i do write('*');        writeln();}`

## Chef

`Asterisks Omelette. This recipe prints a triangle of asterisks. Ingredients.5 eggs1 onion1 potato42 ml water10 ml olive oil1 garlic Method.Put eggs into the mixing bowl.Fold onion into the mixing bowl.Put eggs into the mixing bowl.Add garlic into the mixing bowl.Fold eggs into the mixing bowl.Chop onion.Put onion into the mixing bowl.Fold potato into the mixing bowl.Put olive oil into the mixing bowl.Mash potato.Put water into the mixing bowl.Mash potato until mashed.Chop onion until choped.Pour contents of the mixing bowl into the baking dish. Serves 1.`

## Clojure

`(doseq [i (range 5), j (range (inc i))]  (print "*")  (if (= i j) (println)))`

## COBOL

`       IDENTIFICATION DIVISION.       PROGRAM-ID. Display-Triangle.        DATA DIVISION.       WORKING-STORAGE SECTION.       01  Outer-Counter PIC 9.       01  Inner-Counter PIC 9.         PROCEDURE DIVISION.       PERFORM VARYING Outer-Counter FROM 1 BY 1 UNTIL 5 < Outer-Counter            PERFORM VARYING Inner-Counter FROM 1 BY 1                   UNTIL Outer-Counter < Inner-Counter               DISPLAY "*" NO ADVANCING           END-PERFORM            DISPLAY "" *> Output a newline       END-PERFORM        GOBACK       . `

## ColdFusion

Remove the leading space from the line break tag.

With tags:

`<cfloop index = "i" from = "1" to = "5">  <cfloop index = "j" from = "1" to = "#i#">    *  </cfloop>  < br /></cfloop>`

With script:

`<cfscript>  for( i = 1; i <= 5; i++ )  {    for( j = 1; j <= i; j++ )    {      writeOutput( "*" );    }    writeOutput( "< br />" );  }</cfscript>`

## Common Lisp

`(loop for i from 1 upto 5 do  (loop for j from 1 upto i do    (write-char #\*))  (terpri))`

or

`(dotimes (i 5)  (dotimes (j (+ i 1))    (write-char #\*))  (terpri))`

or

`(do ((i 1 (+ i 1)))    ((> i 5))  (do ((j 1 (+ j 1)))      ((> j i))    (write-char #\*))  (terpri))`

or

`(use-package :iterate)(iter  (for i from 1 to 5)    (iter      (for j from 1 to i)      (princ #\*))    (terpri))`

## Coq

`Section FOR.  Variable T : Type.  Variable body : nat -> T -> T.  Variable start : nat.   Fixpoint for_loop n : T -> T :=    match n with    | O => fun s => s    | S n' => fun s => for_loop n' (body (start + n') s)    end. End FOR. Eval vm_compute in  for_loop _    (fun i =>      cons        (for_loop _          (fun j => cons tt)          0 (S i) nil        )    )    0 5 nil. `

## Crystal

` 1.upto(5) do |i|  1.upto(i) do |j|    print "*"  end  putsend `

Or another way, more succinctly put:

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

## D

`import std.stdio: write, writeln; void main() {    for (int i; i < 5; i++) {        for (int j; j <= i; j++)            write("*");        writeln();    }    writeln();     foreach (i; 0 .. 5) {        foreach (j; 0 .. i + 1)            write("*");        writeln();    }}`
Output:
```*
**
***
****
*****

*
**
***
****
*****```

## Dao

`for( i = 1 : 5 ){    for( j = 1 : i ) io.write( '*' )    io.writeln()}`

## Dart

`main() {    for (var i = 0; i < 5; i++)        for (var j = 0; j < i + 1; j++)            print("*");        print("\n");}`

## dc

[...]sA defines the inner loop A and [...]sB defines the outer loop B. This program nests the entrance to loop A inside loop B.

Translation of: bc
`[ [*]P		[print asterisk]sz lj 1 + d sj	[increment j, leave it on stack]sz li !<A		[continue loop if i >= j]sz]sA[ 1 d sj		[j = 1, leave it on stack]sz li !<A		[enter loop A if i >= j]sz []P		[print newline]sz li 1 + d si	[increment i, leave it on stack]sz 5 !<B		[continue loop if 5 >= i]sz]sB1 d si		[i = 1, leave it on stack]sz5 !<B		[enter loop B if 5 >= i]sz`

## Delphi

`program LoopFor; {\$APPTYPE CONSOLE} var  i, j: Integer;begin  for i := 1 to 5 do  begin    for j := 1 to i do      Write('*');    Writeln;  end;end.`

## DMS

`number i, jfor (i = 1; i <= 5; i++) {    for (j = 1; j <= i; j++)    {        Result( "*" )    }    Result( "\n" )}`

## dodo0

`fun for -> var, test, body, return    # define a for loop using recursion(   test(var) -> continue   if (continue) ->   (      body(var) -> var      for (var, test, body, return)   )   |      return(var))| for fun upToFive (-> index, return) '<='(index, 5, return) | upToFive for (1, upToFive) -> index, return(   fun countTheStars -> stars, return   (      'count'(stars) -> n      '<'(n, index, return)   # continue until n = index   )   | countTheStars    for ("*", countTheStars) -> prefix, return      'str'(prefix, "*", return)   | stars    println(stars) ->    'inc'(index, return))| resultexit()`

## Dragon

`for (i = 0, i < 5, i++) {   for (j = 0, j <= i, j++) {      show "*"   }   showln ""}`

## DWScript

`var i, j : Integer; for i := 1 to 5 do begin   for j := 1 to i do      Print('*');   PrintLn('');end;`

## Dyalect

Translation of: Swift
`for i in 1..5 {    for _ in 1..i {        print("*", terminator = "")    }    print()}`

Output:

```*
**
***
****
*****```

## E

`for width in 1..5 {    for _ in 1..width {        print("*")    }    println()}`

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

## EasyLang

`for i range 5  a\$ = "*"  for j range i    a\$ &= "*"  .  print a\$.`

## EDSAC order code

As with many other machine-level languages, there is no inbuilt looping construct; but the equivalent of a FOR or DO loop can easily be synthesized using conditional branching orders and a control variable.

The EDSAC character set does not include a * character, so + has been used instead.

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.

`[ Loops  =====   A program for the EDSAC   Demonstrates nested loops  and printer output   Works with Initial Orders 2 ]           T56K  [ set load point  ]        GK    [ set theta       ]         [email protected]  [ figure shift    ] [  1 ]  [email protected]  [ a = 0           ]        [email protected]  [ a = i           ] [  3 ]  [email protected]  [ j = a; a = 0    ]        [email protected]  [ write character ]        [email protected]  [ a = j           ]        [email protected]  [ a -= 1          ]        [email protected]  [ j = a           ]        [email protected]   [ if a>=0 go to 3 ]         [email protected]  [ write line feed ]        [email protected]  [ a = 0           ]        [email protected]  [ a = i           ]        [email protected]  [ a += 1          ]        [email protected]  [ i = a           ]        [email protected]  [ a -= 5          ]        [email protected]   [ if a<0 go to 1  ]         ZF    [ halt            ] [ 17 ]  P0D   [ const: 1        ][ 18 ]  P2D   [ const: 5        ] [ 19 ]  P0F   [ var: i          ][ 20 ]  P0F   [ var: j          ] [ 21 ]  #F    [ figure shift    ][ 22 ]  ZF    [ '+' character   ][ 23 ]  &F    [ line feed       ] [ 24 ]  P0F   [ used to clear a ]         EZPF  [ begin execution ]`
Output:
```+
++
+++
++++
+++++```

## EGL

`str string;for ( i int to 5 )   str = "";   for ( j int to i )      str += "*";   end   SysLib.writeStdout(str);end`

## Ela

`open monad io loop m n | n < m = do            loop' n 0            putStrLn ""            loop m (n + 1)         | else = do return ()          where loop' m n | n <= m = do                              putStr "*"                              loop' m (n + 1)                          | else = do return () _ = loop 10 1 ::: IO`

Output:

`******************************************************`

## Elena

ELENA 4.x :

`import extensions; public program(){    for(int i := 0, i < 5, i += 1)    {        for(int j := 0, j <= i, j += 1)            { console.write:"*" };         console.writeLine()    }}`
Output:
```*
**
***
****
*****
```

## Elixir

`defmodule Loops do  def loops_for(n) do    Enum.each(1..n, fn i ->      Enum.each(1..i, fn _ -> IO.write "*" end)      IO.puts ""    end)  endend Loops.loops_for(5)`

one line (Comprehensions)

`for i <- 1..5, do: IO.puts (for j <- 1..i, do: "*")`

## Erlang

`%% Implemented by Arjun Sunel-module(nested_loops).-export([main/0, inner_loop/0]). main() ->	outer_loop(1). inner_loop()->	inner_loop(1). inner_loop(N) when N rem 5 =:= 0 ->	io:format("* "); inner_loop(N) ->	io:fwrite("* "),	inner_loop(N+1). outer_loop(N) when N rem 5 =:= 0 ->	io:format("*"); outer_loop(N) ->	outer_loop(N+1),	io:format("~n"),	inner_loop(N). `

## ERRE

` FOR I=1 TO 5 DO    FOR J=1 TO I DO        PRINT("*";)    END FOR    PRINTEND FOR `

## Euphoria

` for i = 1 to 5 do    for j = 1 to i do        puts(1, "*") -- Same as "puts(1, {'*'})"    end for    puts(1, "\n") -- Same as "puts(1, {'\n'})"end for `

`puts()` is a function that takes two arguments; an `integer` and a `sequence`. Strings are simply `sequence`s; there is no string type. The `integer` specifies where to put the "string". 0 = STDIN, 1 = STDOUT, 2 = STDERR, 3+ = files that are opened with the `open()` function. `puts()` prints the `sequence` out, as a "string". Each element in the `sequence` provided is printed out as the character with that value in the ASCII character chart.

## F#

`#light[<EntryPoint>]let main args =    for i = 1 to 5 do        for j = 1 to i do            printf "*"        printfn ""    0`

## Factor

`5 [1,b] [ [ "*" write ] times nl ] each`

## FALSE

`1[\$6-][\$[\$]["*"1-]#%""1+]#%`

## Fantom

Using for loops:

` class ForLoops{  public static Void main ()  {    for (Int i := 1; i <= 5; ++i)    {      for (Int j := 1; j <= i; ++j)      {         Env.cur.out.print ("*")      }      Env.cur.out.printLine ("")    }  }} `

Using range objects:

` class ForLoops{  public static Void main ()  {    (1..5).each |i|    {      (1..i).each |j|      {         Env.cur.out.print ("*")      }      Env.cur.out.printLine ("")    }  }} `

## FOCAL

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

`01.10 FOR I=1,4; DO 2.0 02.10 FOR J=1,I; TYPE "*"02.20 TYPE !`
Output:
```*
**
***
****
*****```

## Forth

`: triangle ( n -- )  1+ 1 do    cr i 0 do [char] * emit loop  loop ;5 triangle`

One more:

` : limit_example        15 1 do r> [email protected] dup rot >r drop \ Bring limit on stack                . \ And print it        loop ;\ Gforth and JSForth all work, SP-Forth brakes (different 'for' implementation?) `

## Fortran

Works with: Fortran version 77 and later
`C     WARNING: This program is not valid ANSI FORTRAN 77 code. It usesC     one nonstandard character on the line labelled 5001. Many F77C     compilers should be okay with it, but it is *not* standard.      PROGRAM FORLOOP        INTEGER I, J         DO 20 I = 1, 5          DO 10 J = 1, IC           Print the asterisk.            WRITE (*,5001) '*'   10     CONTINUEC         Print a newline.          WRITE (*,5000) ''   20   CONTINUE         STOP  5000   FORMAT (A)C       Standard FORTRAN 77 is completely incapable of completing aC       WRITE statement without printing a newline. If you wanted toC       write this program in valid F77, you would have to come up withC       a creative way of printing varying numbers of asterisks in aC       single write statement.CC       The dollar sign at the end of the format is a nonstandardC       character. It tells the compiler not to print a newline. If youC       are actually using FORTRAN 77, you should figure out what yourC       particular compiler accepts. If you are actually using FortranC       90 or later, you should replace this line with the commentedC       line that follows it. 5001   FORMAT (A, \$)C5001   FORMAT (A, ADVANCE='NO')      END`
Works with: Fortran version 90 and later
`DO i = 1, 5  DO j = 1, i    WRITE(*, "(A)", ADVANCE="NO") "*"  END DO  WRITE(*,*)END DO`

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 version 95 and later
`integer :: iinteger, dimension(10) :: v forall (i=1:size(v)) v(i) = i`

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.

## FreeBASIC

`' FB 1.05.0 Win64 For i As Integer = 1 To 5  For j As Integer = 1 To i    Print "*";  Next  PrintNext Sleep`
Output:
```*
**
***
****
*****
```

## Frink

` for n = 1 to 5{   for a = 1 to n      print["*"]    println[]} `

## Futhark

 This example is incorrect. Please fix the code and remove this message.Details: Futhark's syntax has changed, so this example will not compile

Futhark does not have I/O, so this program simply counts in the inner loop.

` fun main(n: int): [n]int =  loop (a = replicate n 0) = for i < n do    (loop (s = 0) = for j < i+1 do     s + j     let a[i] = s     in a)  in a `

## Gambas

`Public Sub Main()Dim i, j As Integer For i = 1 To 5   For j = 1 To i      Print "*";   Next   PrintNext End`
```*
**
***
****
*****
```

## GAP

`for i in [1 .. 5] do    for j in [1 .. i] do        Print("*");    od;    Print("\n");od; # *# **# ***# ****# *****`

## GML

`pattern = ""for(i = 1; i <= 5; i += 1)    {    for(j = 1; j <= i; j += 1)        {        pattern += "*"        }    pattern += "#"    }show_message(pattern)`

## Go

`package main import "fmt" func main() {    for i := 1; i <= 5; i++ {        for j := 1; j <= i; j++ {            fmt.Printf("*")        }        fmt.Printf("\n")    }}`
Output:
```*
**
***
****
*****
```

## Groovy

Solution:

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

## GW-BASIC

`100 FOR I=1 TO 5110 FOR J=1 TO I120 PRINT "*";130 NEXT J140 PRINT150 NEXT I160 END`
Output:
```*
**
***
****
*****
```

## Hack

`for(\$i = 0; \$i < 5; \$i++) {    for(\$j = 0; \$j <= \$i; \$j++) {        echo '*';    }     echo '\n';}`

## Haskell

`import Control.Monad main = do  forM_ [1..5] \$ \i -> do    forM_ [1..i] \$ \j -> do      putChar '*'    putChar '\n'`

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

`import Data.List (inits) main = mapM_ putStrLn \$ tail \$ inits \$ replicate 5 '*'`

## Haxe

`for (i in 1...6) {	for(j in 0...i) {		Sys.print('*');	}	Sys.println(''); }`

## hexiscript

`for let i 1; i <= 5; i++  for let j 1; j <= i; j++    print "*"  endfor  println ""endfor`

## HicEst

`DO i = 1, 5  DO j = 1, i    WRITE(APPend) "*"  ENDDO  WRITE() ' 'ENDDO`

## HolyC

`U8 i, j;for (i = 1; i <= 5; i++) {  for (j = 1; j <= i; j++)    Print("*");  Print("\n");}`

## Icon and Unicon

### Icon

`procedure main()every i := 1 to 5 do {   every 1 to i do      writes("*")   write()   }end`

### Unicon

The Icon solution works in Unicon.

## Inform 7

`repeat with length running from 1 to 5:	repeat with N running from 1 to length:		say "*";	say line break;`

## J

J is array-oriented, so there is very little need for loops. For example, except for the requirement for loops, one could satisfy this task this way:

```  ]\ '*****'
```

J does support loops for those times they can't be avoided (just like many languages support gotos for those time they can't be avoided).

`3 : 0        for_i. 1 + i. y do.             z =. ''              for. 1 + i. i do.                  z=. z,'*'             end.               z 1!:2 ] 2          end.         i.0 0   )`

But you would almost never see J code like this.

## Java

`for (int i = 0; i < 5; i++) {   for (int j = 0; j <= i; j++) {      System.out.print("*");   }   System.out.println();}`

## JavaScript

`var i, j;for (i = 1; i <= 5; i += 1) {  s = '';  for (j = 0; j < i; j += 1)    s += '*';  document.write(s + '<br>');}`

Alternatively, using JavaScript's Array.forEach(), and given an array of indices, or a simple range function which generates a range:

`function range(i) {  return i ? range(i - 1).concat(i) : [];} range(5) --> [1, 2, 3, 4, 5]`

We could write something like:

`var s = ''; range(5).forEach(  function (line) {    range(line).forEach(      function () { s += '*'; }    );    s += '\n';  }); console.log(s);`

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:

`console.log(  range(5).reduce(    function (a, n) {      return a + Array(n + 1).join('*') + '\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.

`console.log(  range(5).map(function(a) {    return Array(a + 1).join('*');  }).join('\n'));`

## jq

`# Single-string version using explicit nested loops:def demo(m):  reduce range(0;m) as \$i    (""; reduce range(0;\$i) as \$j           (.; . + "*" )  + "\n" ) ; # Stream of strings:def demo2(m):  range(1;m)  | reduce range(0;.) as \$j (""; . + "*"); # Variation of demo2 using an implicit inner loop:def demo3(m): range(1;m) | "*" * . ;`

Example using demo(6)

Output:
```\$ jq -r -n -f loops_for.jq
*
**
***
****
*****
```

## Jsish

Code from Javascript entry.

`var i, j, s;for (i = 1; i <= 5; i += 1) {    s = '';    for (j = 0; j < i; j += 1) s += '*';    puts(s);}`
Output:
```prompt\$ jsish forloop.jsi
*
**
***
****
*****```

## Julia

` for i in 1:5    for j in 1:i        print("*")    end    println()end `
Output:
```*
**
***
****
*****```

## Klong

` :" x{p}:*y means repeat {p} x times starting at y " 5{x{.d(0c*);x}:*0;.p("");x+1}:*1 :" But you would not do it like this! ":" You would reshape 0c* to the desired length ":" in a function and then iterate that function ":" over a vector of numbers: " {.p(x:^0c*)}'1+!5 `

## Kotlin

`fun main(args: Array<String>) {    (1..5).forEach {        (1..it).forEach { print('*') }        println()    }}`

## LabVIEW

This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code. ## Lambdatalk

` {def loops_for {lambda {:i :n}  {if {>= :i :n}   then (end of loop)   else {br}{S.map {lambda {} *} {S.serie 0 :i}}        {loops_for {+ :i 1} :n}}}}-> loops_for {loops_for 0 5}-> * * * * * * * * * * * * * * * (end of loop) a simpler way, using {S.map function {S.serie start end [step]} {S.map {lambda {:i} {br} {S.map {lambda {:i} *} {S.serie 1 :i}}}{S.serie 1 5}}->  *  * *  * * *  * * * *  * * * * * `

## Lang5

`: cr  "\n" . ;      : dip  swap '_ set execute _ ;: nip  swap drop ;  : last  -1 extract nip ;: times    swap iota '_ set    do   dup 'execute dip _ last 0 == if break then    loop drop ; : concat  "" join ;'* 1 5 "2dup reshape concat . cr 1 +" times`

## langur

`for .i = 0; .i < 5; .i += 1 {    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 .i of 5 {    for of .i {        write "*"    }    writeln()}`

Or, with one for loop...

`for .i of 5 {    writeln "*" x .i}`

## Lasso

`loop(5) => {^    loop(loop_count) => {^ '*' ^}    '\r'^}`

## LC3 Assembly

`      .ORIG      0x3000       AND        R1,R1,0      ADD        R1,R1,1      AND        R5,R5,0      ADD        R5,R5,5      NOT        R5,R5 LOOPI LD         R0,STAR      AND        R2,R2,0      ADD        R3,R1,0 LOOPJ OUT      ADD        R2,R2,1      NOT        R4,R2      ADD        R4,R3,R4      BRZP       LOOPJ       LD         R0,LF      OUT       ADD        R1,R1,1      ADD        R4,R1,R5      BRN        LOOPI       HALT STAR  .FILL      0x2ALF    .FILL      0x0A       .END`

Output:

```*
**
***
****
*****```

## 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 i 1} {\$i <= 5} {inc i} {    for {set j 1} {\$j <= \$i} {inc j} {        write "*"    }    print}`
Output:
```prompt\$ lil loopsFor.lil
*
**
***
****
*****```

The for statement in LIL, like Tcl, is pretty flexible and is not limited to simple incremented variable style loops.

## Lingo

`repeat with i = 1 to 5  str = ""  repeat with j = 1 to i    put "*" after str  end repeat  put strend repeat`

## Lisaac

`1.to 5 do { i : INTEGER;  1.to i do { dummy : INTEGER;    '*'.print;  };  '\n'.print;};`

## LiveCode

`put 0 into nrepeat for 5 times                                                                                                     add 1 to n  repeat for n times    put "*"  end repeat  put returnend repeat`

## Logo

`for [i 1 5] [repeat :i [type "*] (print)]repeat 5 [repeat repcount [type "*] (print)]`

## Lua

` for i=1,5 do  for j=1,i do    io.write("*")  end  io.write("\n")end `

## 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 "*";      Next j      PrintNext iPrint "End1"For i=1 to 5 {      For j=1 to i {            Print "*";      }      Print}Print "End2" `

## M4

`define(`for',   `ifelse(\$#,0,``\$0'',   `ifelse(eval(\$2<=\$3),1,   `pushdef(`\$1',\$2)\$5`'popdef(`\$1')\$0(`\$1',eval(\$2+\$4),\$3,\$4,`\$5')')')')dnl for(`x',`1',`5',`1',   `for(`y',`1',x,`1',      `*')')`

## make

Works with: BSD make
Library: jot
`all: line-5 ILIST != jot 5.for I in \$(ILIST) line-\$(I): asterisk-\$(I)-\$(I)	@echo JLIST != jot \$(I). for J in \$(JLIST) .  if "\$(J)" == "1".   if "\$(I)" == "1"asterisk-1-1:.   elseIM != expr \$(I) - 1asterisk-\$(I)-1: line-\$(IM).   endif.  elseJM != expr \$(J) - 1asterisk-\$(I)-\$(J): asterisk-\$(I)-\$(JM).  endif	@printf \* . endfor.endfor`

## Maple

`> for i to 5 do to i do printf( "*" ) end; printf( "\n" ) end;***************`

## Mathematica

`n=5;For[i=1,i<=5,i++, string=""; For[j=1,j<=i,j++,string=string<>"*"]; Print[string]]`

## MATLAB / Octave

`for i = (1:5)    output = [];    for j = (1:i)        output = [output '*'];    end    disp(output);end`

Vectorized version:

`for i = (1:5)    disp(repmat('*',1,i));end`

## Maxima

`for i thru 5 do (   s: "",   thru i do s: sconcat(s, "*"),   print(s));`

## MAXScript

`for i in 1 to 5 do(    line = ""    for j in 1 to i do    (        line += "*"    )    format "%\n" line)`

## Mercury

`:- module loops_for.:- interface. :- import_module io.:- pred main(io::di, io::uo) is det. :- implementation.:- import_module int. main(!IO) :-   int.fold_up(outer_loop_body, 1, 5, !IO). :- pred outer_loop_body(int::in, io::di, io::uo) is det. outer_loop_body(I, !IO) :-   int.fold_up(inner_loop_body, 1, I, !IO),   io.nl(!IO). :- pred inner_loop_body(int::in, io::di, io::uo) is det. inner_loop_body(_, !IO) :-   io.write_char('*', !IO).`

## MiniScript

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

`for i in range(1,5)    s = ""    for j in range(1, i)        s = s + "*"    end for    print send for`
Output:
```*
**
***
****
*****```

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

`for i in range(1,5)    print "*" * iend for`

(Output same as above.)

## Modula-2

`MODULE For;  IMPORT InOut;   VAR    i, j: INTEGER; BEGIN  FOR i := 1 TO 5 DO    FOR j := 1 TO i DO      InOut.Write('*');    END;    InOut.WriteLn  ENDEND For.`

## Modula-3

`MODULE Stars EXPORTS Main; IMPORT IO; BEGIN  FOR i := 1 TO 5 DO    FOR j := 1 TO i DO      IO.Put("*");    END;    IO.Put("\n");  END;END Stars.`

## MOO

`for i in [1..5]  s = "";  for j in [1..i]    s += "*";  endfor  player:tell(s);endfor`

## Morfa

` import morfa.base; for (i in 0..5) {    for (j in 0..i+1)     {        print("*");    }    println("");} `

## MUMPS

### Routine

`FORLOOP NEW I,J FOR I=1:1:5 DO .FOR J=1:1:I DO ..WRITE "*" .WRITE ! QUIT`
Output:
```USER>D FORLOOP^ROSETTA
*
**
***
****
*****
```

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

`FOR I=1:1:5 FOR J=1:1:I WRITE "*" IF J=I W !`

## Nanoquery

`for (\$i = 1) (\$i <= 5) (\$i = \$i+1)    for (\$j = 0) (\$j < \$i) (\$j = \$j+1)        print "*"    end for    printlnend for`

## Nemerle

`for (int i = 0; i < 5; i++){    for (int j = 0; j <= i; j++)    {        Write("*");    }    WriteLine();}`

## NetRexx

`/* NetRexx */options replace format comments java crossref savelog symbols nobinary   say  say 'Loops/For'   loop i_ = 1 to 5    loop for i_      say '*\-'      end    say    end i_ `

## NewLISP

` (for (i 1 5)  (for(j 1 i)    (print "*"))  (print "\n")) `

## Nim

`for i in 1..5:  for j in 1..i:    stdout.write("*")  echo("")`

## NS-HUBASIC

`10 FOR I=1 TO 520 FOR J=1 TO I30 PRINT "*";40 NEXT50 PRINT60 NEXT`

## Oberon-2

Works with oo2c Version 2

` MODULE LoopFor;IMPORT   Out;VAR  i, j: INTEGER; BEGIN  FOR i := 1 TO 5 DO    FOR j := 1 TO i DO      Out.Char('*');    END;    Out.Ln  ENDEND LoopFor. `

## Objeck

` bundle Default {  class For {    function : Main(args : String[]) ~ Nil {      DoFor();    }     function : native : DoFor() ~ Nil {    	for (i := 0; i < 5; i += 1;) {          for (j := 0; j <= i; j += 1;) {            "*"->Print();          };          ""->PrintLine();	       };    }  }} `

## OCaml

`for i = 1 to 5 do  for j = 1 to i do    print_string "*"  done;  print_newline ()done`

## Octave

`for i = 0:1:4  for j = 0:1:i    printf("*");  endfor  printf("\n");endfor`

## Oforth

`: loopFor(n)| i j |   n loop: i [      i loop: j [ "*" print ]      printcr ;`

## Onyx

`1 1 5 {dup {`*'} repeat bdup bpop ncat `\n' cat print} for flush`

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

## Order

`#include <order/interpreter.h> ORDER_PP(  8for_each_in_range(8fn(8I,                         8print(                           8for_each_in_range(8fn(8J, 8print((*))),                                              1, 8plus(8I, 1))                           8space)),                         1, 6))`

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

## Oz

`for I in 1..5 do   for _ in 1..I do      {System.printInfo "*"}   end   {System.showInfo ""}end`

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

## Panoramic

` dim x,y for x=1 to 5     for y=1 to x     print "*";     next y print next x `

## PARI/GP

`for(a=1,5,for(b=1,a,print1("*"));print())`

## Pascal

`program stars(output); var  i, j: integer; begin  for i := 1 to 5 do    begin      for j := 1 to i do        write('*');      writeln    endend.`

## Perl

`for(my \$x = 1; \$x <= 5; \$x++) {  for(my \$y = 1; \$y <= \$x; \$y++) {    print "*";  }   print "\n";}`
`foreach (1..5) {  foreach (1..\$_) {    print '*';  }  print "\n";}`

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

`print ('*' x \$_ . "\n") for 1..5;`

or equivalently

`map {print '*' x \$_ . "\n"} 1..5;`

## Phix

```for i=1 to 5 do
for j=1 to i do
puts(1,"*")
end for
puts(1,"\n")
end for
```

## PHP

`for (\$i = 1; \$i <= 5; \$i++) {  for (\$j = 1; \$j <= \$i; \$j++) {    echo '*';  }  echo "\n";}`

or

`foreach (range(1, 5) as \$i) {  foreach (range(1, \$i) as \$j) {    echo '*';  }  echo "\n";}`

or

`foreach (range(1, 5) as \$i)  echo str_repeat('*', \$i) , PHP_EOL;`

## PicoLisp

`(for N 5   (do N (prin "*"))   (prinl) )`

## Pike

`int main(){   for(int i = 1; i <= 5; i++){      for(int j=1; j <= i; j++){         write("*");      }      write("\n");   }}`

## 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 `\$stars` each time round and then print it in the outer loop.

`C  :i = 1*OuterLoopC  :j = 0C  :\$stars =*InnerLoopC  :j = j + 1C  :\$stars =*\$starsJ ( j < i )          :*InnerLoopT  :\$starsC  :i = i + 1J ( i < 6 )          :*OuterLoopEND:`

## PL/I

Basic version:

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

Advanced version:

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

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

`put edit ((('*' do j = 1 to i)do i=1 to 5))(a);  /* no new line */`

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

`To run:Start up.Write a triangle of asterisks on the console given 5.Wait for the escape key.Shut down. To write a row of asterisks on the console given a number:If a counter is past the number, write "" on the console; exit.Write "*" on the console without advancing.Repeat. To write a triangle of asterisks on the console given a size:If a counter is past the size, exit.Write a row of asterisks on the console given the counter.Repeat.`

## Pop11

`lvars i, j;for i from 1 to 5 do    for j from 1 to i do        printf('*','%p');    endfor;    printf('\n')endfor;`

## PowerShell

`for (\$i = 1; \$i -le 5; \$i++) {    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 `ForEach-Object` cmdlet:

`1..5 | ForEach-Object {    1..\$_ | ForEach-Object {        Write-Host -NoNewline *    }    Write-Host}`

while the inner loop wouldn't strictly be necessary and can be replaced with simply `"*" * \$_`.

## Processing

`size( 105,120 ); for ( int i=20; i<=100; i+=20 )   for ( int j=10; j<=i; j+=20 )      text( "*", j,i );`

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

`example :-     between(1,5,I), nl, between(1,I,_J),    write('*'), fail.example.`
```?- example.

*
**
***
****
*****
true.```

## Python

`import sysfor i in xrange(5):    for j in xrange(i+1):        sys.stdout.write("*")    print`

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:

`for i in range(1,6):    print '*' * i`

or

`print('\n'.join('*' * i for i in range(1, 6)))`

## QB64

CBTJD: 2020/03/14

`FOR c = 1 TO 5    FOR n = 1 TO c        PRINT "*";    NEXT    PRINTNEXT`

## Quackery

`5 times [ i^ 1+ times [ say "*" ] cr ]`
Output:
```*
**
***
****
*****
```

## R

`for(i in 0:4) {  s <- ""  for(j in 0:i) {    s <- paste(s, "*", sep="")  }  print(s)}`

## Racket

`(for ([i (in-range 1 6)]) (for ([j i]) (display "*")) (newline))`

## Raku

(formerly Perl 6)

Works with: Rakudo version #22 "Thousand Oaks"
`for ^5 { 	for 0..\$_ {		print "*";	} 	print "\n"; }`

or using only one for loop:

`say '*' x \$_ for 1..5;`

or without using any loops at all:

`([\~] "*" xx 5).join("\n").say;`

## REBOL

`; Use 'repeat' when an index required, 'loop' when repetition suffices: repeat i 5 [	loop i [prin "*"] 	print ""] ; or a more traditional for loop: for i 1 5 1 [	loop i [prin "*"]	print ""]`

## Retro

`6 [ 0; cr [ '* emit ] times ] iter`

## REXX

### using concatenation

`/*REXX program demonstrates an outer DO loop controlling the inner DO loop with a "FOR".*/        do j=1  for 5                             /*this is the same as:   do j=1  to 5  */       \$=                                        /*initialize the value to a null string*/              do k=1  for j                      /*only loop for a   J   number of times*/              \$= \$ || '*'                        /*using concatenation  (||)  for build.*/              end   /*k*/       say \$                                     /*display character string being built.*/       end          /*j*/                        /*stick a fork in it,  we're all done. */`
output:
```*
**
***
****
*****
```

### using abutment

`/*REXX program demonstrates an outer DO loop controlling the inner DO loop with a "FOR".*/        do j=1  for 5                             /*this is the same as:   do j=1  to 5  */       \$=                                        /*initialize the value to a null string*/              do k=1  for j                      /*only loop for a   J   number of times*/              \$= \$'*'                            /*using abutment for the construction. */              end   /*k*/       say \$                                     /*display character string being built.*/       end          /*j*/                        /*stick a fork in it,  we're all done. */`
output   is identical to the 1st REXX version.

## 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 "*"      next     see nl next `

## Ruby

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

for Range#each
`for i in 1..5  for j in 1..i    print "*"  end  putsend`
`(1..5).each do |i|  (1..i).each do |j|    print "*"  end  putsend`

Ruby has other ways to code these loops; Integer#upto is most convenient.

Integer#upto Integer#times Kernel#loop
`1.upto(5) do |i|  1.upto(i) do |j|    print "*"  end  putsend`
`5.times do |i|  # i goes from 0 to 4  (i+1).times do    print "*"  end  putsend`
`i = 1loop do  j = 1  loop do    print "*"    break if (j += 1) > i  end  puts  break if (i += 1) > 5end`

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

`puts (1..5).map { |i| "*" * i }`

## Rust

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

`fn main() {    for i in 0..5 {        for _ in 0..=i {            print!("*");        }         println!();    }}`

## Salmon

`iterate (x; [0...4])  {    iterate (y; [0...x])        print("*");;    print("\n");  };`

or

`for (x; 0; x < 5)  {    for (y; 0; y <= x)        print("*");;    print("\n");  };`

## SAS

`data _null_;length a \$5;do n=1 to 5;  a="*";  do i=2 to n;    a=trim(a) !! "*";  end;  put a;end;run; /* Possible without the inner loop. Notice TRIM is replaced with STRIP,otherwise there is a blank space on the left */ data _null_;length a \$5;do n=1 to 5;  a=strip(a) !! "*";  put a;end;run;`

## Sather

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

`class MAIN is  -- from, to, step  for!(once init:INT, once to:INT, once inc:INT):INT is    i ::= init;    loop while!( i <= to );      yield i;      i := i + inc;    end;  end;   main is    i, j :INT;    loop i := for!(1, 5, 1);   -- 1.upto!(5)      loop j := for!(1, i, 1); -- 1.upto!(i)        #OUT + "*";      end;      #OUT + "\n";    end;  end;end; `

## Scala

`for (i <- 1 to 5) {    for (j <- 1 to i)        print("*")    println()}`

## Scheme

`(do ((i 1 (+ i 1)))    ((> i 5))    (do ((j 1 (+ j 1)))        ((> j i))        (display "*"))    (newline))`

## Scilab

Works with: Scilab version 5.5.1
`for i=1:5    s=""    for j=1:i        s=s+"*"    end    printf("%s\n",s)end`
Output:
```*
**
***
****
*****```

## Seed7

`for I range 1 to 5 do  for J range 1 to I do    write("*");  end for;  writeln;end for;`

## SETL

`for i in {1..5} loop    for j in {1..i} loop        nprint( '*' );    end loop;    print;    -- new lineend loop;`

## Sidef

for(;;) loop:

`for (var i = 1; i <= 5; i++) {    for (var j = 1; j <= i; j++) {        print '*'    }    print "\n"}`

for([]) loop:

`for (1..5) { |i|    for (1..i) { print '*' }    print "\n"}`

for-in loop:

`for i in (1..5) {    for j in (1..i) { print '*' }    print "\n"}`

Idiomatic:

`5.times { |i|    i.times { print '*' }    print "\n"}`

## Simula

Works with: SIMULA-67
`begin   integer i,j;   for i:=1 step 1 until 5 do    begin       for j:=1 step 1 until i do          outtext("*");      outimage   endend `

## Slate

`1 to: 5 do: [| :n | inform: (\$* repeatedTimes: n)].`

## Smalltalk

`1 to: 5 do: [ :aNumber |  aNumber timesRepeat: [ '*' display ].  Character nl display.]`

or:

`1 to: 5 do: [ :row |  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
`1 to: 5 do: [ :n |  Stdout next: n put: \$*; cr]`

## SNOBOL4

A slightly longer, "mundane" version

`ol	outer = ?lt(outer,5) outer + 1	:f(end)	inner = outer; stars = ""il	stars = ?gt(inner,0) stars "*"	:f(disp)	inner = inner - 1	:(il)disp	output = stars;	:(ol)end`

The "real SNOBOL4" starts here:

`outer	b = a = ?lt(a,5) a + 1	:f(end)inner	t = t ?(b = (gt(b,0) b - 1)) "*"	:s(inner)	t span("*") . terminal = 	:(outer)end`

one "loop" only:

`	a = "*****"; a	a len(x = x + 1) . output	:s(a)end`

... or just (courtesy of GEP2):

Works with: SNOBOL4 version which defaults to anchored mode
`        "*****" arb \$ output failend`

## SNUSP

```       / \
<
< <
< /<<<<<.\
. ?
> \->>>>>/
> !
> >
! >
/>-\ />+>+\
? ?
\+</ \ -<</
< !
< +
- >
/   !\?/#
\+++++>+++++++++++++>\
/++++++++++++++++++++++/
\++++++++++++++++++++\
\$/
```
```*
**
***
****
*****
```

## Sparkling

`for (var row = 1; row <= 5; row++) {    for (var col = 1; col <= row; col++) {        printf("*");    }     print();}`

## Spin

Works with: BST/BSTC
Works with: FastSpin/FlexSpin
Works with: HomeSpun
Works with: OpenSpin
`con  _clkmode = xtal1 + pll16x  _clkfreq = 80_000_000 obj  ser : "FullDuplexSerial.spin" pub main | m, n  ser.start(31, 30, 0, 115200)   repeat n from 1 to 5    repeat m from 1 to n      ser.tx("*")    ser.str(string(13,10))   waitcnt(_clkfreq + cnt)  ser.stop  cogstop(0)`
Output:
```*
**
***
****
*****
```

## SPL

`> i, 1..5  > j, 1..i    #.output("*",#.rs)  <  #.output()<`

## Stata

`forvalues n=1/5 {	local s ""	forvalues i=1/`n' {		local s `s'*	}	display "`s'"}`

### Mata

`for (i=1; i<=5; i++) {	for (j=1; j<=i; j++) printf("*")	printf("\n")}`

## Suneido

`for(i = 0; i < 5; ++i)    {    str = ''    for (j = 0; j <= i; ++j)        str \$= '*'    Print(str)    }`

## Swift

`for i in 1...5 {    for _ in 1...i {        print("*", terminator: "")    }    print()}`
Output:
```*
**
***
****
*****
```

## Tailspin

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

` 1..5 -> '\$:1..\$ -> '*';' -> !OUT::write `
Output:
```*
**
***
****
*****
```

## Tcl

`for {set lines 1} {\$lines <= 5} {incr lines} {    for {set i 1} {\$i <= \$lines} {incr i} {        puts -nonewline "*"    }    puts ""}`

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

`for {set i 1} {\$i <= 5} {incr i} {    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:

`set 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)

## TI-83 BASIC

For loops in TI-83 BASIC take at least 3 arguments, with an optional fourth: For(variable,start,end[,step]. Parentheses don't need to be closed in TI-BASIC.

```ClrHome
For(I,1,5
For(J,1,I
Output(I,J,"*
End
End
```

## TI-89 BASIC

`Local i,jClrIOFor i, 1, 5  For j, 1, i    Output i*8, j*6, "*"  EndForEndFor`

## TorqueScript

`for(%i = 0; %i < 5; %i++){    for(%x = %i; %x < 5; %x++)    {        %string = %string @ "*";        echo(%string);    }}`

## TransFORTH

`: PRINTSTARS ( ROWS -- )1 + 1 DOI 0 DOPRINT " * " LOOPCR LOOP ;5 PRINTSTARS`

## TUSCRIPT

` \$\$ MODE TUSCRIPTm=""LOOP n=1,5 m=APPEND (m,"","*") PRINT mENDLOOP `
Output:
```*
**
***
****
*****
```

## TypeScript

`for (let i: number = 0; i < 5; ++i) {    let line: string = ""    for(let j: number = 0; j <= i; ++j) {        line += "*"    }    console.log(line)} `

## UNIX Shell

A conditional loop, using a while control construct, can have the same effect as a for loop. (The original Bourne Shell has no `echo -n "*"`, so this uses `printf "*"`.)

Works with: Bourne Shell
`#!/bin/sh# Using a while control construct to emulate a for loop l="1"                   # Set the counters to onewhile [ "\$l" -le 5 ]    # Loop while the counter is less than five  do  m="1"  while [ "\$m" -le "\$l" ]  # Loop while the counter is less than five    do    printf "*"    m=`expr "\$m" + 1`   # Increment the inner counter  done  echo  l=`expr "\$l" + 1`   # Increment the outer counterdone`

The Bourne Shell has a for loop, but it requires a list of words to iterate. The jot(1) command from BSD can output an appropriate list of numbers.

Works with: Bourne Shell
Library: jot
`for i in `jot 5`; do	for j in `jot \$i`; do		printf \*	done	echodone`

Bash has for loops that act like C. These loops are very good for this task.

Works with: Bourne Again SHell version 3
`for (( x=1; \$x<=5; x=\$x+1 )); do   for (( y=1; y<=\$x; y=\$y+1 )); do     echo -n '*'  done  echo ""done`

### C Shell

Library: jot
`foreach i (`jot 5`)	foreach j (`jot \$i`)		echo -n \*	end	echo ""end`

### Korn Shell

Works with: Korn Shell 93
`for ((x=1; x<=5; x=x+1)); do   for ((y=1; y<=x; y=y+1)); do     echo -n '*'  done  echo ""done `

## UnixPipes

`yes \ | cat -n | (while read n ; do  [ \$n -gt 5 ] && exit 0;  yes \* | head -n \$n | xargs -n \$n echodone)`

## Ursa

`## for loop# decl int i jfor (set i 0) (< i 5) (inc i)        for (set j 0) (< j (int (+ i 1))) (inc j)                out "*" console        end for        out endl consoleend for`

## Vala

`int main (string[] args) {    for (var i = 1; i <= 5; i++) {        for (var j = 1; j <= i; j++) {	    stdout.putc ('*');        }        stdout.putc ('\n');    }    return 0;}`

## VBA

`Option ExplicitSub LoopEx()    Dim i As Long, j As Long, s As String    For i = 1 To 5        s = ""        For j = 1 To i            s = s + "*"        Next        Debug.Print s    NextEnd Sub`

## VBScript

`Option ExplicitDim i, j, sFor i = 1 To 5    s = ""    For j = 1 To i        s = s + "*"    Next    WScript.Echo sNext`

## Vedit macro language

`for (#1 = 1; #1 <= 5; #1++) {    for (#2 = 1; #2 <= #1; #2++) {        Type_Char('*')    }    Type_Newline}`

## Wart

`for i 1 (i <= 5) ++i  for j 0 (j < i) ++j    pr "*"  (prn)`

## Wee Basic

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

`for y=0 to 4print 1 ""for x=0 to yprint 1 at x,y "*"nextnextend`

## Wren

`for (i in 1..5) {    for (j in 1..i) System.write("*")    System.print()}`
Output:
```*
**
***
****
*****
```

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

`loops:      mov       bx,      1    ; outer loop counter outerloop:  mov       cx,      bx   ; inner loop counter            mov       dl,      42   ; '*' character innerloop:  mov       ah,      6            int       21h           ; print             dec       cx            jcxz      innerdone            jmp       innerloop innerdone:  mov       dl,      10   ; newline            mov       ah,      6            int       21h             inc       bx            cmp       bx,      6            jne       outerloop             ret`

## XBasic

Works with: Windows XBasic
` PROGRAM "for" DECLARE FUNCTION Entry() FUNCTION Entry()  FOR i% = 1 TO 5    FOR j% = 1 TO i%      PRINT "*";    NEXT j%    PRINT  NEXT i%END FUNCTIONEND PROGRAM `

## XLISP

The equivalent of other languages' FOR or DO loops can be written using DO:

`(DO ((I 1 (+ I 1))) ((> I 5))    (DO ((J 0 (+ J 1))) ((= J I))        (DISPLAY "*"))    (NEWLINE))`
Output:
```*
**
***
****
*****```

This construct is not, however, very idiomatic: loops in XLISP are mostly written using recursion.

## XPL0

`code ChOut=8, CrLf=9;int I, J;for I:= 1 to 5 do    [for J:= 1 to I do        ChOut(0, ^*);    CrLf(0);    ]`

## Z80 Assembly

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

`org &4000		; put code at memory address 0x4000wr_char equ &bb5a ; write ASCII character in register A to screen				; (jumps into CPC ROM) ; put registers on stack so we can return to BASIC laterpush bcpush depush hl ld b,5		; loop from 5 to 1 row: push bc	; save outer loop variable ; calculate inner loop limit (6 - outer loop variable)ld a,6sub bld b,a column: ld a,42	; asterisk in ASCIIcall wr_chardjnz column ; decrement B, jump to label if non-zero pop bc	; restore outer loop ; print carriage return/line feedld a,13call wr_charld a,10call wr_char djnz row ; restore registerspop hlpop depop bcret	; return to BASIC interpreter`

## zkl

`foreach i in ([1..5]){   foreach j in (i){print("*")}   println();}`
Output:
```*
**
***
****
*****
```