Loops/Nested: Difference between revisions

{{task|Iteration}} [[Category:Loop modifiers]]

Show a nested loop which searches a two-dimensional array filled with random numbers uniformly distributed over <math>[1,\ldots,20]</math>.

The loops iterate rows and columns of the array printing the elements until the value <math>20</math> is met.

Specifically, this task also shows how to [[Loop/Break|break]] out of nested loops.

 

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

LOOPNEST CSECT

USING LOOPNEST,R12

RANDSEED DC F'16807' running n

YREGS

{{out}}

<pre> 3 4 1 11 13 17 11 9 8 2 15 19 16 18 1 9 7 16 12 3

11 13 13 6 13 19 9 18 11 4 7 8 6 7 2 10 14 4 5 1

16 14 13 6 11 20</pre>

 

=={{header|Ada}}==

with Ada.Numerics.Discrete_Random;

 

New_Line;

end loop Outer;

{{out|Sample output}}

<pre>

5 5 17 15 17 2 5 5 17 13

16 10 10 20

</pre>

 

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards)}}

[10][10]INT a; INT i, j;

 

xkcd com 292:

print(new line)

{{out|Sample output}}

<pre>

12 20

</pre>

 

=={{header|AutoHotkey}}==

{

i := A_Index

finish:

MsgBox % "a[" . i . "][" . j . "]" is 20

 

=={{header|AWK}}==

To break from two loops, this program uses two <tt>break</tt> statements and one <tt>b</tt> flag.

rows = 5

columns = 5

print

}

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

CLS

FOR row = 1 TO 10

IF a(row, col) = 20 THEN END

NEXT col

 

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

{{works with|BBC BASIC for Windows}}

FOR row% = 0 TO 10

FOR col% = 0 TO 10

NEXT

NEXT row%

EXIT FOR can jump out of multiple nested loops by specifying a control variable.

 

Arrays have only one dimension, so we use ''a[i * c + j]'' instead of ''a[i, j]''.

{{trans|AWK}}

 

/* Random number from 1 to 20. */

"

}

 

=={{header|C}}==

Using goto (note: gotos are [http://en.wikipedia.org/wiki/Considered_harmful considered harmful]):

#include <time.h>

#include <stdio.h>

printf("\n");

return 0;

 

srand(time(NULL));

return 0;

 

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

Uses goto as C# has no way to break from multiple loops

 

class Program {

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

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

}

}

Console.WriteLine();

}

 

=={{header|Chapel}}==

 

var nums:[1..10, 1..10] int;

}

writeln();

 

=={{header|Clojure}}==

We explicitly return a status flag from the inner loop:

 

(defn create-matrix [width height]

(when rs (recur rs)))))

 

 

=={{header|COBOL}}==

PROGRAM-ID. Nested-Loop.

 

 

GOBACK

 

=={{header|ColdFusion}}==

<Cfset RandNum = 0>

<Cfloop condition="randNum neq 20">

<br>

</Cfloop>

 

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

(dotimes (i 10)

(dotimes (j 10)

(return-from outer)))

(terpri))

 

=={{header|D}}==

 

void main() {

 

writeln();

 

=={{header|dc}}==

A single ''Q'' command can break multiple nested loops.

{{trans|bc}}

 

[*

]sL

0 d si [i = 0]sz

In this program, ''li lj + 3 + Q'' breaks both the inner loop and the outer loop. We must count how many levels of string execution to break. Our loops use tail recursion, so each iteration is a level of string execution. We have i + 1 calls to outer loop L, and j + 1 calls to inner loop I, and 1 call to condition D; so we break i + j + 3 levels with ''li lj + 3 + Q''.

 

=={{header|E}}==

 

escape done {

}

}

 

=={{header|EchoLisp}}==

(lib 'math) ;; for 2D-arrays

(define array (build-array 42 42 (lambda(i j) (1+ (random 20)))))

→ 9 8 11 1 14 11 1 9 16 1 10 5 5 6 5 4 13 17 14 13 6 10 16 4 8 5 1 17 16 19 4 6 18 1 15 3 4 13 19

6 12 5 5 17 19 16 3 7 2 15 16 14 16 16 19 18 14 16 6 18 14 17 20

 

=={{header|Elixir}}==

def nested do

list = Enum.shuffle(1..20) |> Enum.chunk(5)

IO.inspect list, char_lists: :as_lists

end

 

 

{{out|Sample output}}

8 7 12 17 9

6 20 done

</pre>

 

=={{header|Erlang}}==

-module( loops_nested ).

 

 

random_array( Size ) -> [random:uniform(Size) || _X <- lists:seq(1, Size)].

 

=={{header|ERRE}}==

DIM A%[10,10] ! in declaration part

.............

! use a boolean variable or a GOTO label statement

END FOR

 

=={{header|Euphoria}}==

a = rand(repeat(repeat(20, 10), 10))

 

exit

end if

<code>exit</code> only breaks out of the innermost loop. A better way to do this would be a procedure.

 

=={{header|Fantom}}==

There is no specific way to break out of nested loops (such as a labelled break, or goto). Instead, we can use exceptions and a try-catch block.

{

public static Void main ()

echo ("No 20")

}

 

=={{header|Forth}}==

 

10 constant X

20 = if unloop unloop exit then

loop

 

=={{header|Fortran}}==

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

INTEGER A, I, J, RNDINT

 

ENDIF

RETURN

{{out|Sample output}}

<pre>A[ 1][ 1] is 2

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

Here the special feature is that later Fortran allows loops to be labelled (with "outer" in this example) on their first and last statements. Any EXIT or CYCLE statements can then mention the appropriate label so as to be clear just which loop is involved, otherwise the assumption is the innermost loop only. And no "GO TO" statements need appear.

implicit none

 

end do outer

{{out|Sample output}}

<pre>

14 2 1 11 8 1 14 11 3 15

7 15 16 6 7 17 3 20

</pre>

 

=={{header|GAP}}==

n := 40;

a := List([1 .. n], i -> List([1 .. n], j -> Random(1, 20)));;

end;

 

 

=={{header|Go}}==

 

import (

}

fmt.Printf("\n")

 

=={{header|Groovy}}==

{{Trans|Java}}

Solution:

def a = []

(0..<10).each {

}

}

{{out}}

<pre>[1, 19, 14, 16, 3, 12, 14, 18, 12, 6]

 

=={{header|Haskell}}==

breakIncl p = uncurry ((. take 1). (++)). break p

 

{{out|Example}}

2

6

10

13

 

=={{header|HicEst}}==

 

array = NINT( RAN(10,10) )

ENDDO

 

 

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

Icon and Unicon use 'break' to exit loops and execute an expression argument. To exit nested loops 'break' is repeated as the expression.

 

every !(!(L := list(10)) := list(10)) := ?20 # setup a 2d array of random numbers up to 20

break break write("L[",i,",",j,"]=20")

 

if x = 20 then break write("L[",i,",",j,"]=20") # more succinctly

 

 

=={{header|J}}==

 

Here's how the problem could be solved, using loops:

end.

end.

{{out|Example use}}

<pre> use ?.20 20 $ 21

The first approach is probably a couple thousand times faster than the second.

 

 

=={{header|Java}}==

 

public class NestedLoopTest {

System.out.println();

}

 

=={{header|JavaScript}}==

Demonstrates use of <code>break</code> with a label.

Uses <code>print()</code> function from [[Rhino]].

var a = [[2, 12, 10, 4], [18, 11, 9, 3], [14, 15, 7, 17], [6, 19, 8, 13], [1, 20, 16, 5]];

 

}

}

 

In a functional idiom of JavaScript, however, we can not use a loop statement, as statements return no value and can not be composed within other functional expressions. Functional JavaScript often replaces a loop with a map or fold. In this case, we can achieve the same task by defining the standard list-processing function '''takeWhile''', which terminates when a condition returns true.

Using the same data as above, and returning the trail of numbers up to twenty from a nested and composable expression:

 

20, 16, 5]];

 

return a.concat(x);

}).join('\n')

 

Output:

12

10

8

13

 

=={{header|Julia}}==

M = [rand(1:20) for i in 1:5, j in 1:10]

R, C = size(M)

end

end

{{out}}

<pre>

</pre>

Julia is column ordered, but this program searches in row order to be consistent with the other solutions of this task.

 

=={{header|Lasso}}==

 

array(2, 12, 10, 4),

array(18, 11, 9, 3),

#1 == 20 ? return

}

 

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

for i = 1 to 10

for j = 1 to 10

if flag then exit for

next

 

=={{header|Lisaac}}==

 

+ name := TEST_LOOP_NESTED;

};

'\n'.print;

 

=={{header|LiveCode}}==

repeat with j = 1 to 10

put random(20) into aNums[i,j]

else

put "20 not found"

 

=={{header|Logo}}==

 

for [j 1 10] [for [i 1 10] [mdsetitem list :i :j :a (1 + random 20)]]

]

end

 

=={{header|Lua}}==

for i = 1, 20 do

t[i] = {}

end

end

 

=={{header|Maple}}==

for i from 1 to m do

for j from 1 to n do

end if;

end do;

 

If[m[[i, j]] === 20, Return[]],

{i, 1, Dimensions[m][[1]]},

 

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

Loops are considered slow in Matlab and Octave, it is preferable to vectorize the code.

A non-vectorized version of the code is shown below in Octave

 

=={{header|Maxima}}==

 

find_value(a, x) := block(

 

find_value(data, 100);

 

=={{header|MAXScript}}==

fn scan_Nested arr =

(

)

)

 

Example:

testArray = #(#(1,5,2,19),#(11,20,7,2))

scan_nested testArray

OK

 

 

=={{header|MOO}}==

for i in [1..10]

for j in [1..10]

s = "";

endfor

 

=={{header|MUMPS}}==

;.../loops/nested

;set up the 2D array with random values

FOR I=1:1:K Q:FLAG W ! FOR J=1:1:K WRITE A(I,J),$SELECT(J'=K:", ",1:"") SET FLAG=(A(I,J)=TRIGGER) Q:FLAG

KILL A,I,J,K,FLAG,TRIGGER

{{out}}

<pre>USER>D NESTLOOP^ROSETTA

9, 10, 10, 13, 2, 9, 6, 10, 1, 12, 12, 10, 8, 1, 13

7, 14, 12, 9, 14, 3, 20,</pre>

 

=={{header|Nemerle}}==

{{trans|C#}}

Nemerle can jump out of a named block by invoking the blocks name with an optional return value.

using System.Console;

using Nemerle.Imperative;

}

}

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols nobinary

 

finally

say

I was somewhat disappointed by the performance of the above program

and started a little performance analysis on solutions of this task

 

=={{header|NewLISP}}==

(dotimes (i 10)

(dotimes (j 10)

(print " ")

(if (= 20 (a i j))

 

=={{header|Nim}}==

 

 

 

 

 

block outer:

{{out}}

<pre> 9, 16, 3, 18, 4, 17, 2, 16, 7, 6,

1, 6, 1, 11, 9, 8, 12, 7, 19, 8,

13, 16, 4, 5, 2, 20</pre>

 

=={{header|OCaml}}==

In the interactive interpreter:

 

 

# Random.self_init();;

15 3 5 19 17 3 1 11 5 2

1 1 6 19 20

 

=={{header|Octave}}==

Octave has no way of exiting nested loop; so we need a control variable, or we can use the trick of embedding the loops into a function and use the <tt>return</tt> statement. (The search for "exactly 20" is changed into a search for "almost 20")

% create a 100x100 matrix...

m = unifrnd(0,20, 100,100);

break;

endif

 

=={{header|OoRexx}}==

do i = 1 to 10

do j = 1 to 10

leave i

end

 

=={{header|Oz}}==

We can directly access and use the outer loop's break procedure:

fun {CreateMatrix Width Height}

Matrix = {List.make Height}

end

in

 

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

 

=={{header|Pascal}}==

{{works with|FreePascal|1.0}}

uses SysUtils;

const Ni=10; Nj=20;

end;

loopend:

 

=={{header|Perl}}==

 

Outer:

print "\n";

}

 

=={{header|Phix}}==

use an explicit flag

alternatively you can use a procedure

 

=={{header|PHP}}==

for ($i = 0; $i < 10; $i++)

for ($j = 0; $j < 10; $j++)

}

echo "\n";

 

=={{header|PicoLisp}}==

(T

(for N Lst

(printsp N)

or:

(for Lst (make (do 10 (link (make (do 10 (link (rand 1 20)))))))

(for N Lst

(printsp N)

 

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

x = random()*20 + 1;

loops:

end;

if x(i,j) = 20 then leave;

 

=={{header|PureBasic}}==

Dim Value(10, 5)

For a = 0 To 10

EndIf

Next

 

=={{header|Python}}==

Python has only inner loop breaks. The normal way to solve this problem in Python is to move the code in a function, and use return:

 

def do_scan(mat):

 

mat = [[randint(1, 20) for x in xrange(10)] for y in xrange(10)]

The , after print element suppresses printing a line break. The code needs some minor changes for Python 3.

 

Two more solutions around this problem, the first uses exception handling:

 

class Found20(Exception):

print

except Found20:

The second uses a flag variable:

 

mat = [[randint(1, 20) for x in xrange(10)] for y in xrange(10)]

print

if found20:

 

=={{header|Qi}}==

(define random-list

0 -> []

 

(array->list 20 (random-array 10 10))

 

=={{header|R}}==

n <- 10

mat <- matrix(sample(1:20L, m*n, replace=TRUE), nrow=m); mat

break

}

 

or

 

m <- 10; n <- 10; mat <- matrix(sample(1:20L, m*n, replace=TRUE), nrow=m);

x<-which(mat==20,arr.ind=TRUE,useNames=FALSE)

for(i in mat[1:x[1,1]-1,]) print(i)

for(i in mat[x[1,1],1:x[1,2]]) print(i)

 

=={{header|Racket}}==

#lang racket

(define (scan xss)

(+ (random 20) 1))))

 

 

=={{header|REBOL}}==

Title: "Loop/Nested"

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

]

]

]

{{out}}

<pre>Loop break using state variable:

02 13 14 14 15 01 10 07 17 03

07 17 20</pre>

 

=={{header|REXX}}==

to contain the target (20), it's possible to not find the target.

<br>Code was added to this REXX program to reflect that possibility and issue an appropriate message (whether the target was found or not).

end /*row*/

end /*col*/

do c=1 for cols

end /*c*/

end /*r*/

 

<pre>

@.1.1 = 19

─────────────────Found target: 20

</pre>

<pre>

@.1.1 = 14

 

=={{header|Ring}}==

size = 5

array = newlist(size,size)

for col = 1 to size

see "row " + row + " col " + col + "value : " + array[row][col] + nl

next

next

next

return aList

Output:

<pre>

row 5 col 5 value : 6

</pre>

 

=={{header|Ruby}}==

As the break command only jumps out of the innermost loop,

this task requires Ruby's <code>catch/throw</code> functionality.

p ary

 

end

 

{{out}}

<pre>[[2, 12, 10, 4], [18, 11, 9, 3], [14, 15, 7, 17], [6, 19, 8, 13], [1, 20, 16, 5]]

6 19 8 13 ,

1 20 done</pre>

However, for-loops are not very popular. This is more idiomatic ruby, which avoids loops and breaking out of them:

 

element == 20

end

{{out}}

<pre>

</pre>

 

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

cls

for row = 1 TO 10

next row

[end]

 

=={{header|Rust}}==

 

extern crate rand;

if item == 20 { break 'outer }

}

}

{{out}}

<pre> 5 3 8 18 13 2 5 13 6 17

 

=={{header|Sather}}==

main is

a:ARRAY2{INT} := #(10,10);

end;

end;

 

=={{header|Scala}}==

In Scala there is no build-in 'break' keyword. That functionality comes from a library.

val a=Array.fill(5,4)(scala.util.Random.nextInt(21))

println(a map (_.mkString("[", ", ", "]")) mkString "\n")

if (x==20) break

}

{{out}}

<pre>[14, 16, 5, 7]

=={{header|Scheme}}==

Using call/cc:

(lambda (return)

(for-each (lambda (a)

a)

(newline))

Using tail-call:

(if (pair? a)

(let loop2 ((b (car a)))

(else

(display " ")(display (car b))

 

=={{header|Scilab}}==

{{works with|Scilab|5.5.1}}

t=int(rand(ni,nj)*20)+1

for i=1:ni

printf("\n")

if t(i,j)==11 then break; end

{{out}}

<pre> 5 18 19 8

 

=={{header|Seed7}}==

 

const proc: main is func

catch FOUND20: writeln;

end block;

 

{{out}}

 

=={{header|Sidef}}==

 

"%3d".printf(num);

}

 

{{out}}

<pre> 9 17 14 17 17 7 1 3 9 18

it looks a bit wierd, but here is: loopWithExit

 

 

i := 1.

i == 5 ifTrue:[ exit value:'stopped' ].

i := i + 1.

these can also be nested, and exited from the inner loop:

 

i := 1.

] loopWithExit.

i := i + 1

in case your smalltalk does not have it, here's the definition:

loopWithExit

"the receiver must be a block of one argument. It is evaluated in a loop forever,

 

exitBlock := [:exitValue | ^ exitValue].

in the same spirit, exits could be added to many other loop constructs. However, this is really only very rarely needed in Smalltalk, because a ^(return) out of a block returns from the enclosing method which usually used to exit early from search utility methods.

 

There is also valueWithExit, which can be used to get out of a block early and provide an alternative value. Using that, the tasks solution is:

 

v := 1 to:20 collect:[:i |

] ifFalse:[

'20 found at ' print. result printCR

{{out}}

<pre>19

 

The following code implements a BiArray class with a method that allows iteration over the elements (by columns and then by rows) and execution of a block if a condition is true.

lacks controls over the indexes, but has a way of iterating

over array's elements, from left to right and top to bottom"

"loop searching for 20; each block gets the element passed as argument"

biarr whileTrue: [ :v | v ~= 20 ]

=={{header|Swift}}==

 

loop: for row in array {

}

}

{{out}}

<pre> 2

done

</pre>

 

=={{header|Tcl}}==

Tcl only supports single-level breaks; exiting more deeply nested looping requires the use of exceptions, which are considerably more verbose before Tcl 8.6.

{{works with|Tcl|8.6}}

 

try {

}

} trap MULTIBREAK {} {}

{{out}}

<pre> 12 13 14 13 15,

 

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

(A,B)→dim([C])

For(I,1,A)

End

 

 

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

The <code>Stop</code> statement exits the containing ''program''.

Local mat,i,j

© randMat(5, 5) exists but returns -9 to 9 rather than 1 to 20

EndFor

EndFor

 

=={{header|TUSCRIPT}}==

LOOP

row=""

ENDLOOP

PRINT row

{{out}}

<pre>

{{works with|Bash}}

Bash doesn't have two-dimentional arrays, so we fake it for this example

 

for ((i=0;i<size;i++)); do

echo

done

{{out|Example output}}

<pre> 7 5 4 6 4 5 2 15 10 7

15 4 14 9 10 14 14 3 3 5

14 20 </pre>

 

=={{header|XPL0}}==

def Size=10;

 

[Fill(Array);

Nest(Array);

 

=={{header|zkl}}==

Using nested lists to simulate a 5x5 array. No breakbreak so an exception is used to long jump out of the loop (just 'cause, a state var could also be used).

var rows=(0).pump(N,List, (0).pump.fp(N,List,(1).random.fpM("1-",21)) );

try{

}

println("Not found");

{{out}}

<pre>

 

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

20 FOR i=1 TO 10: FOR j=1 TO 10

30 LET a(i,j)=INT (RND*20)+1

100 IF b=0 THEN PRINT

110 NEXT i

{{out|Example output}}

<pre>

 

{{omit from|GUISS|No loops or nesting, and we can't read our values}}