Jump to content

Loops/Break

From Rosetta Code
Task
Loops/Break
You are encouraged to solve this task according to the task description, using any language you may know.
Task

Show a loop which prints random numbers (each number newly generated each loop) from 0 to 19 (inclusive).

If a number is 10, stop the loop after printing it, and do not generate any further numbers.

Otherwise, generate and print a second random number before restarting the loop.

If the number 10 is never generated as the first number in a loop, loop forever.


Related tasks



11l

Translation of: Python
L
   V a = random:(20)
   print(a)
   I a == 10
      L.break
   V b = random:(20)
   print(b)

360 Assembly 

*        Loops Break               15/02/2017
LOOPBREA CSECT
         USING  LOOPBREA,R13       base register
         B      72(R15)            skip savearea
         DC     17F'0'             savearea
         STM    R14,R12,12(R13)    prolog
         ST     R13,4(R15)         " <-
         ST     R15,8(R13)         " ->
         LR     R13,R15            " addressability
LOOP     MVC    PG,=CL80' '        clean buffer
         LA     R8,PG              ipg=0
         BAL    R14,RANDINT        call randint
         C      R6,=F'10'          if k=10 then leave
         BE     ENDLOOP             <-- loop break
         BAL    R14,RANDINT        call randint
         XPRNT  PG,L'PG            print buffer
         B      LOOP               loop forever
ENDLOOP  XPRNT  PG,L'PG            print buffer
         L      R13,4(0,R13)       epilog 
         LM     R14,R12,12(R13)    " restore
         XR     R15,R15            " rc=0
         BR     R14                exit
RANDINT  L      R5,RANDSEED        randint
         M      R4,=F'397204091'   "
         D      R4,=X'7FFFFFFF'    "
         ST     R4,RANDSEED        "
         LR     R5,R4              "
         SR     R4,R4              "
         D      R4,=F'20'          "
         LR     R6,R4              k=randint(20)
         XDECO  R6,XDEC            edit k
         MVC    0(4,R8),XDEC+8     output k
         LA     R8,4(R8)           ipg=ipg+4
         BR     R14                return
RANDSEED DC     F'39710831'        seed
PG       DS     CL80               buffer
XDEC     DS     CL12
         YREGS
         END    LOOPBREA
Output:
   2   3
   9  10
  14   5
  18  16
   5   0
   1   3
   7  17
  19   8
  17  12
  10

6502 Assembly

Code is called as a subroutine (i.e. JSR LoopBreakSub). Specific OS/hardware routines for generating random numbers and printing are left unimplemented. 

LoopBreakSub:	PHA			;push accumulator onto stack


BreakLoop:	JSR GenerateRandomNum	;routine not implemented
		;generates random number and puts in memory location RandomNumber

		LDA RandomNumber
		JSR DisplayAccumulator	;routine not implemented
		CMP #10
		BEQ Break
		JSR GenerateRandomNum
		LDA RandomNumber
		JSR DisplayAccumulator
		JMP BreakLoop

Break:		PLA			;restore accumulator from stack
		RTS			;return from subroutine

AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits
/* ARM assembly AARCH64 Raspberry PI 3B */
/*  program loopbreak64.s   */
 
/*******************************************/
/* Constantes file                         */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"

/*********************************/
/* Initialized data              */
/*********************************/
.data
szMessEndLoop: .asciz "loop break with value : \n"
szMessResult:  .asciz "Resultat = @ \n"      // message result

.align 4
qGraine:  .quad 12345678
/*********************************/
/* UnInitialized data            */
/*********************************/
.bss 
sZoneConv:               .skip 24
/*********************************/
/*  code section                 */
/*********************************/
.text
.global main 
main:                          // entry of program 
1:                             // begin loop 
    mov x4,20
2:
    mov x0,19
    bl genereraleas            // generate number
    cmp x0,10                  // compar value
    beq 3f                     // break if equal
    ldr x1,qAdrsZoneConv       // display value
    bl conversion10            // call function with 2 parameter (x0,x1)
    ldr x0,qAdrszMessResult
    ldr x1,qAdrsZoneConv
    bl strInsertAtCharInc      // insert result at third @ character
    bl affichageMess           // display message final
    subs x4,x4,1                 // decrement counter
    bgt 2b                     // loop if greather
    b 1b                       // begin loop one
 
3:
    mov x2,x0                  // save value
    ldr x0,qAdrszMessEndLoop
    bl affichageMess           // display message
    mov x0,x2
    ldr x1,qAdrsZoneConv                
    bl conversion10            // call function with 2 parameter (x0,x1)
    ldr x0,qAdrszMessResult
    ldr x1,qAdrsZoneConv
    bl strInsertAtCharInc      // insert result at third @ character
    bl affichageMess           // display message
 
100:                           // standard end of the program 
    mov x0,0                   // return code
    mov x8,EXIT                // request to exit program
    svc 0                      // perform the system call
 
qAdrsZoneConv:            .quad sZoneConv
qAdrszMessResult:         .quad szMessResult
qAdrszMessEndLoop:        .quad szMessEndLoop
 
/***************************************************/
/*   Generation random number                  */
/***************************************************/
/* x0 contains limit  */
genereraleas:
    stp x1,lr,[sp,-16]!    // save  registers
    stp x2,x3,[sp,-16]!    // save  registers
    ldr x3,qAdrqGraine     // load graine
    ldr x2,[x3]
    lsr x1,x2,17           // see xorshift on wikipedia
    eor x2,x2,x1
    lsl x1,x2,31
    eor x2,x2,x1
    lsr x1,x2,8
    eor x1,x2,x1
    str x1,[x3]            // save graine for the next call 
    udiv x1,x2,x0          // divide by value maxi
    msub x0,x1,x0,x2       // résult = remainder
100:                       // end function
    ldp x2,x3,[sp],16      // restaur  2 registers
    ldp x1,lr,[sp],16      // restaur  2 registers
    ret                    // return to address lr x30
/********************************************************************/
qAdrqGraine: .quad qGraine
/********************************************************/
/*        File Include fonctions                        */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
Output:
Resultat = 1
Resultat = 8
Resultat = 11
Resultat = 11
Resultat = 5
Resultat = 3
Resultat = 5
Resultat = 12
Resultat = 18
Resultat = 14
loop break with value :
Resultat = 10

Action! 

PROC Main()
  BYTE v

  PrintE("Before loop")
  DO
    v=Rand(20)
    PrintBE(v)
    IF v=10 THEN
      EXIT
    FI
  OD
  PrintE("After loop")
RETURN
Output:

Screenshot from Atari 8-bit computer 

Before loop
2
6
3
4
11
17
5
17
10
After loop

Ada 

with Ada.Text_IO;  use Ada.Text_IO;
with Ada.Numerics.Discrete_Random;

procedure Test_Loop_Break is
   type Value_Type is range 0..19;
   package Random_Values is new Ada.Numerics.Discrete_Random (Value_Type);
   use Random_Values;
   Dice : Generator;
   A, B : Value_Type;
begin
   loop
      A := Random (Dice);
      Put_Line (Value_Type'Image (A));
      exit when A = 10;
      B := Random (Dice);
      Put_Line (Value_Type'Image (B));
   end loop;
end Test_Loop_Break;

Aime 

integer
main(void)
{
    integer a, b;

    while (1) {
        a = drand(19);
        o_integer(a);
        o_byte('\n');
        if (a == 10) {
            break;
        }

        b = drand(19);
        o_integer(b);
        o_byte('\n');
    }

    return 0;
}

ALGOL 60

Works with: ALGOL 60 version OS/360
'BEGIN' 'COMMENT' Loops/Break - ALGOL60 - 18/06/2018;
  'INTEGER' SEED;
  'INTEGER' 'PROCEDURE' RANDOM(N);
  'VALUE' N; 'INTEGER' N;
  'BEGIN'
    SEED:=(SEED*19157+12347) '/' 21647;
    RANDOM:=SEED-(SEED '/' N)*N+1
  'END' RANDOM;
  'INTEGER' I,J,K;
  SYSACT(1,6,120);SYSACT(1,8,60);SYSACT(1,12,1);'COMMENT' open print;
  SEED:=31567;
  J:=0;
  'FOR' I:=1, I+1 'WHILE' I 'LESS' 100 'DO' 'BEGIN'
    J:=J+1;
    K:=RANDOM(20);
    OUTINTEGER(1,K);
    'IF' J=8 'THEN' 'BEGIN'
       SYSACT(1,14,1);  'COMMENT' skip line;
       J:=0
    'END';
    'IF' K=10 'THEN' 'GOTO' LAB
  'END';
LAB:
  SYSACT(1,14,1);  'COMMENT' skip line;
'END'
Output:
        +17           +4          +20           +3          +16           +5           +1          +17  
        +11           +2          +12           +5           +7           +6          +10

ALGOL 68

Translation of: C – Note: This specimen retains the original C coding style.
Works with: ALGOL 68 version Standard - no extensions to language used
Works with: ELLA ALGOL 68 version Any (with appropriate job cards)
main: (
    INT a, b;
    INT seed := 4; # chosen by a fair dice roll, guaranteed to be random c.f. http://xkcd.com/221/ #
    # first random; #
    WHILE
        a := ENTIER (next random(seed) * 20);
        print((a));
  # WHILE # NOT (a = 10) DO
        b := ENTIER (next random(seed) * 20);
        print((b, new line))
    OD;
    print(new line)
)
Output:
        +13          +6
         +1          +8
        +13          +2
         +1         +12
         +0         +12
        +14          +8
         +9          +2
        +19         +13
         +0          +4
         +8         +14
        +17          +7
        +11          +9
         +7          +8
         +2          +1
        +11          +2
        +13         +18
         +3          +7
        +11         +17
         +4         +13
        +16         +12
        +19         +17
         +9          +7
         +8          +5
         +4          +8
         +7          +5
         +0         +18
         +8         +13
         +7          +4
        +10

AppleScript 

repeat
	set a to random number from 0 to 19
	if a is 10 then
		log a
		exit repeat
	end if
	set b to random number from 0 to 19
	log a & b
end repeat


Output:
(*12, 6*)
(*7, 8*)
(*17, 4*)
(*7, 2*)
(*0, 5*)
(*6, 3*)
(*5, 5*)
(*3, 14*)
(*7, 7*)
(*3, 11*)
(*5, 16*)
(*18, 2*)
(*5, 2*)
(*15, 17*)
(*16, 10*)
(*4, 18*)
(*8, 5*)
(*4, 15*)
(*11, 14*)
(*7, 2*)
(*1, 7*)
(*7, 7*)
(*4, 9*)
(*12, 17*)
(*8, 16*)
(*9, 1*)
(*16, 15*)
(*8, 2*)
(*9, 6*)
(*13, 6*)
(*17, 0*)
(*17, 18*)
(*4, 7*)
(*8, 10*)
(*11, 0*)
(*14, 17*)
(*9, 8*)
(*2, 17*)
(*1, 5*)
(*4, 5*)
(*5, 2*)
(*10*)

Arc 

(point break
  (while t
    (let x (rand 20)
      (prn "a: " x)
      (if (is x 10)
        (break)))
    (prn "b: " (rand 20))))

ARM Assembly

Works with: as version Raspberry Pi
/* ARM assembly Raspberry PI  */
/*  program loopbreak.s   */

/* Constantes    */
.equ STDOUT, 1     @ Linux output console
.equ EXIT,   1     @ Linux syscall
.equ WRITE,  4     @ Linux syscall

/*********************************/
/* Initialized data              */
/*********************************/
.data
szMessEndLoop: .asciz "loop break with value : \n"
szMessResult:  .ascii "Resultat = "      @ message result
sMessValeur:   .fill 12, 1, ' '
                   .asciz "\n"
.align 4
iGraine:  .int 123456
/*********************************/
/* UnInitialized data            */
/*********************************/
.bss 
/*********************************/
/*  code section                 */
/*********************************/
.text
.global main 
main:                @ entry of program 
    push {fp,lr}      @ saves 2 registers 
1:    @ begin loop 
    mov r4,#20
2:
    mov r0,#19
    bl genereraleas               @ generate number
    cmp r0,#10                       @ compar value
    beq 3f                         @ break if equal
    ldr r1,iAdrsMessValeur     @ display value
    bl conversion10             @ call function with 2 parameter (r0,r1)
    ldr r0,iAdrszMessResult
    bl affichageMess            @ display message
    subs r4,#1                   @ decrement counter
    bgt 2b                      @ loop if greather
    b 1b                          @ begin loop one
	
3:
    mov r2,r0             @ save value
    ldr r0,iAdrszMessEndLoop
    bl affichageMess            @ display message
    mov r0,r2
    ldr r1,iAdrsMessValeur                
    bl conversion10       @ call function with 2 parameter (r0,r1)
    ldr r0,iAdrszMessResult
    bl affichageMess            @ display message

100:   @ standard end of the program 
    mov r0, #0                  @ return code
    pop {fp,lr}                 @restaur 2 registers
    mov r7, #EXIT              @ request to exit program
    svc #0                       @ perform the system call

iAdrsMessValeur:          .int sMessValeur
iAdrszMessResult:         .int szMessResult
iAdrszMessEndLoop:        .int szMessEndLoop
/******************************************************************/
/*     display text with size calculation                         */ 
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
    push {r0,r1,r2,r7,lr}      @ save  registres
    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" 
    svc #0                      @ call systeme 
    pop {r0,r1,r2,r7,lr}        @ restaur des  2 registres */ 
    bx lr                       @ return  
/******************************************************************/
/*     Converting a register to a decimal                                 */ 
/******************************************************************/
/* r0 contains value and r1 address area   */
conversion10:
    push {r1-r4,lr}    @ save registers 
    mov r3,r1
    mov r2,#10

1:	   @ start loop
    bl divisionpar10 @ r0 <- dividende. quotient ->r0 reste -> r1
    add r1,#48        @ digit	
    strb r1,[r3,r2]  @ store digit on area
    sub r2,#1         @ previous position
    cmp r0,#0         @ stop if quotient = 0 */
    bne 1b	          @ else loop
    @ and move spaces in first on area
    mov r1,#' '   @ space	
2:	
    strb r1,[r3,r2]  @ store space in area
    subs r2,#1       @ @ previous position
    bge 2b           @ loop if r2 >= zéro 

100:	
    pop {r1-r4,lr}    @ restaur registres 
    bx lr	          @return
/***************************************************/
/*   division par 10   signé                       */
/* Thanks to http://thinkingeek.com/arm-assembler-raspberry-pi/*  
/* and   http://www.hackersdelight.org/            */
/***************************************************/
/* r0 dividende   */
/* r0 quotient */	
/* r1 remainder  */
divisionpar10:	
  /* r0 contains the argument to be divided by 10 */
    push {r2-r4}   /* save registers  */
    mov r4,r0 
    mov r3,#0x6667   @ r3 <- magic_number  lower
    movt r3,#0x6666  @ r3 <- magic_number  upper
    smull r1, r2, r3, r0   @ r1 <- Lower32Bits(r1*r0). r2 <- Upper32Bits(r1*r0) 
    mov r2, r2, ASR #2     /* r2 <- r2 >> 2 */
    mov r1, r0, LSR #31    /* r1 <- r0 >> 31 */
    add r0, r2, r1         /* r0 <- r2 + r1 */
    add r2,r0,r0, lsl #2   /* r2 <- r0 * 5 */
    sub r1,r4,r2, lsl #1   /* r1 <- r4 - (r2 * 2)  = r4 - (r0 * 10) */
    pop {r2-r4}
    bx lr                  /* leave function */

/***************************************************/
/*   Generation random number                  */
/***************************************************/
/* r0 contains limit  */
genereraleas:
    push {r1-r4,lr}    @ save registers 
    ldr r4,iAdriGraine
    ldr r2,[r4]
    ldr r3,iNbDep1
    mul r2,r3,r2
    ldr r3,iNbDep1
    add r2,r2,r3
    str r2,[r4]     @ maj de la graine pour l appel suivant 

    mov r1,r0        @ divisor
    mov r0,r2        @ dividende
    bl division
    mov r0,r3       @  résult = remainder
  
100:                @ end function
    pop {r1-r4,lr}   @ restaur registers
    bx lr            @ return
/********************************************************************/
iAdriGraine: .int iGraine	
iNbDep1: .int 0x343FD
iNbDep2: .int 0x269EC3 
/***************************************************/
/* integer division unsigned                       */
/***************************************************/
division:
    /* r0 contains dividend */
    /* r1 contains divisor */
    /* r2 returns quotient */
    /* r3 returns remainder */
    push {r4, lr}
    mov r2, #0                @ init quotient
    mov r3, #0                @ init remainder
    mov r4, #32               @ init counter bits
    b 2f
1:          @ loop 
    movs r0, r0, LSL #1     @ r0 <- r0 << 1 updating cpsr (sets C if 31st bit of r0 was 1)
    adc r3, r3, r3           @ r3 <- r3 + r3 + C. This is equivalent to r3 <- (r3 << 1) + C 
    cmp r3, r1               @ compute r3 - r1 and update cpsr 
    subhs r3, r3, r1        @ if r3 >= r1 (C=1) then r3 <- r3 - r1 
    adc r2, r2, r2           @ r2 <- r2 + r2 + C. This is equivalent to r2 <- (r2 << 1) + C 
2:
    subs r4, r4, #1          @ r4 <- r4 - 1 
    bpl 1b                  @ if r4 >= 0 (N=0) then loop
    pop {r4, lr}
    bx lr

Arturo 

while ø [
    a: random 0 19
    prints [a ""]
    if a=10 -> break

    b: random 0 19
    print b
]
print ""
Output:
11  1
11  16
19  14
17  0
18  11
9  9
1  15
5  5
1  16
7  10
10

AutoHotkey 

Loop
{
  Random, var, 0, 19
  output = %output%`n%var%
  If (var = 10)
    Break
  Random, var, 0, 19
  output = %output%`n%var%
}
MsgBox % output

Avail 

rng ::= a pRNG;
checked : [0..19];
Do [
    checked : = rng's next [0..19];
    Print: “checked”;
] while checked ≠ 10 alternate with [
    Print: " " ++ “rng's next [0..19]” ++ "\n";
];

This demonstrates two interesting Avail features: the alternate with loop structures, which provide two separate code blocks that are run with a check in between, and the random number generator's ability to pick an item from the ranger of a given number type ([0..19] is an expression generating a type whose values are integers in the range 0-19 inclusive).

AWK 

BEGIN {
    srand()  # randomize the RNG
	for (;;) {
		print n = int(rand() * 20)
		if (n == 10)
			break
		print int(rand() * 20)
	}
}

Axe

Because Axe only supports breaking out of loops as end conditions, the behavior must be simulated using a return statement. Note, however, that this will exit the current call context, not the necessarily just the current loop. 

While 1
 rand^20→A
 Disp A▶Dec
 ReturnIf A=10
 rand^20→B
 Disp B▶Dec,i
End

BASIC

Applesoft BASIC 

FOR I = 0 TO 1 STEP 0 : N = INT(RND(1) * 20) : PRINT " "N; : IF N <> 10 THEN ? ","INT(RND(1) * 20); : NEXT

BaCon 

REPEAT
    number = RANDOM(20) 
    PRINT "first  " ,number
        IF number = 10 THEN 
            BREAK
        ENDIF
    PRINT "second  ",RANDOM(20) 
UNTIL FALSE

BASIC256 

do
	i = int(rand * 19)
	print i; "  ";
	if i = 10 then exit do
	i = int(rand * 19)
	print i; "  ";
until false
print
end

Commodore BASIC

In Commodore BASIC, the function RND() generates a floating point number from 0.0 to 1.0 (exclusive). 

10 X = RND(-TI) : REM SEED RN GENERATOR
20 A = INT(RND(1)*20)
30 PRINT A
40 IF A = 10 THEN 80
50 B = INT(RND(1)*20)
60 PRINT B
70 GOTO 20
80 END

IS-BASIC 

100 RANDOMIZE 
110 DO
120   LET A=RND(20)+1
130   PRINT A,
140   IF A=10 THEN EXIT DO
150   PRINT RND(20)+1
160 LOOP

QuickBASIC

Works with: QuickBasic version 4.5
do
    a = int(rnd * 20)
    print a
    if a = 10 then exit loop 'EXIT FOR works the same inside FOR loops
    b = int(rnd * 20)
    print b
loop


True BASIC 

RANDOMIZE

DO
   LET i = INT(RND * 19)
   PRINT i; "  ";
   IF i = 10 THEN
      EXIT DO
   END IF
   LET i = INT(RND * 19)
   PRINT i; "  ";
LOOP
PRINT
END


ZX Spectrum Basic

On the ZX Spectrum, for loops must be terminated through the NEXT statement, otherwise a memory leak will occur. To terminate a loop prematurely, set the loop counter to the last iterative value and jump to the NEXT statement: 

10 FOR l = 1 TO 20
20 IF l = 10 THEN LET l = 20: GO TO 40: REM terminate the loop
30 PRINT l
40 NEXT l
50 STOP

The correct solution: 

10 LET a = INT (RND * 20)
20 PRINT a
30 IF a = 10 THEN STOP
40 PRINT INT (RND * 20)
50 GO TO 10

Batch File 

@echo off
:loop
  set /a N=%RANDOM% %% 20
  echo %N%
  if %N%==10 exit /b
  set /a N=%RANDOM% %% 20
  echo %N%
goto loop

BBC BASIC

Works with: BBC BASIC for Windows
      REPEAT
        num% = RND(20)-1
        PRINT num%
        IF num%=10 THEN EXIT REPEAT
        PRINT RND(20)-1
      UNTIL FALSE

bc 

s = 1  /* seed of the random number generator */
scale = 0

/* Random number from 0 to 20. */
define r() {
	auto a
	while (1) {
		/* Formula (from POSIX) for random numbers of low quality. */
		s = (s * 1103515245 + 12345) % 4294967296
		a = s / 65536       /* a in [0, 65536) */
		if (a >= 16) break  /* want a >= 65536 % 20 */
	}
	return (a % 20)
}


while (1) {
	n = r()
	n    /* print 1st number */
	if (n == 10) break
	r()  /* print 2nd number */
}
quit

Befunge 

>60v  *2\<
  >?>\1-:|
   1+    $
   >^    7
 v.:%++67<
 >55+-#v_@
       >60v  *2\<
         >?>\1-:|
          1+    $
          >^    7
^         .%++67<

C 

int main(){
	time_t t;
	int a, b;
	srand((unsigned)time(&t));
	for(;;){
		a = rand() % 20;
		printf("%d\n", a);
		if(a == 10)
			break;
		b = rand() % 20;
		printf("%d\n", b);
	}
	return 0;
}

Output (example): 

12
18
2
8
10
18
9
9
4
10

C# 

class Program
{
    static void Main(string[] args)
    {
        Random random = new Random();
        while (true)
        {
            int a = random.Next(20);
            Console.WriteLine(a);
            if (a == 10)
                break;
            int b = random.Next(20)
            Console.WriteLine(b);
        }
           
        Console.ReadLine();
    }       
}

C++ 

#include <iostream>
#include <ctime>
#include <cstdlib>

int main(){
	srand(time(NULL)); // randomize seed
	while(true){
		const int a = rand() % 20; // biased towards lower numbers if RANDMAX % 20 > 0
		std::cout << a << std::endl;
		if(a == 10)
			break;
		const int b = rand() % 20;
		std::cout << b << std::endl;
	}
	return 0;
}

Chapel 

use Random;

var r = new RandomStream();
while true {
        var a = floor(r.getNext() * 20):int;
        writeln(a);
        if a == 10 then break;
        var b = floor(r.getNext() * 20):int;
        writeln(b);
}
delete r;

Chef

"Liquify" is now depreciated in favor of "Liquefy", but my interpreter/compiler (Acme::Chef) works only with "Liquify" so that's how I'm leaving it. At least it'll work no matter which version you use. 

Healthy Vita-Sauce Loop - Broken.

Makes a whole lot of sauce for two people.

Ingredients.
0 g Vitamin A
1 g Vitamin B
2 g Vitamin C
3 g Vitamin D
4 g Vitamin E
5 g Vitamin F
6 g Vitamin G
7 g Vitamin H
8 g Vitamin I
9 g Vitamin J
10 g Vitamin K
11 g Vitamin L
12 g Vitamin M
13 g Vitamin N
14 g Vitamin O
15 g Vitamin P
16 g Vitamin Q
17 g Vitamin R
18 g Vitamin S
19 g Vitamin T
20 g Vitamin U
21 g Vitamin V
22 g Vitamin W
32 g Vitamin X
24 g Vitamin Y
25 g Vitamin Z

Method.
Liquify Vitamin X.
Put Vitamin N into 1st mixing bowl.
Fold Vitamin Y into 1st mixing bowl.
Liquify Vitamin Y.
Clean 1st mixing bowl.
Put Vitamin K into 1st mixing bowl.
Fold Vitamin Z into 1st mixing bowl.
Liquify Vitamin Z.
Clean 1st mixing bowl.
Put Vitamin Y into 4th mixing bowl.
Put Vitamin Z into 4th mixing bowl.
Pour contents of the 4th mixing bowl into the 2nd baking dish.
Put Vitamin A into 2nd mixing bowl. Put Vitamin B into 2nd mixing bowl. Put Vitamin C into 2nd mixing bowl. Put Vitamin D into 2nd mixing bowl. Put Vitamin E into 2nd mixing bowl. Put Vitamin F into 2nd mixing bowl. Put Vitamin G into 2nd mixing bowl. Put Vitamin H into 2nd mixing bowl. Put Vitamin I into 2nd mixing bowl. Put Vitamin J into 2nd mixing bowl. Put Vitamin K into 2nd mixing bowl. Put Vitamin L into 2nd mixing bowl. Put Vitamin M into 2nd mixing bowl. Put Vitamin N into 2nd mixing bowl. Put Vitamin O into 2nd mixing bowl. Put Vitamin P into 2nd mixing bowl. Put Vitamin Q into 2nd mixing bowl. Put Vitamin R into 2nd mixing bowl. Put Vitamin S into 2nd mixing bowl. Put Vitamin T into 2nd mixing bowl.
Verb the Vitamin V.
Mix the 2nd mixing bowl well.
Fold Vitamin U into 2nd mixing bowl.
Put Vitamin U into 3rd mixing bowl.
Remove Vitamin K from 3rd mixing bowl.
Fold Vitamin V into 3rd mixing bowl.
Put Vitamin X into 1st mixing bowl.
Put Vitamin V into 1st mixing bowl.
Verb until verbed.
Pour contents of the 1st mixing bowl into the 1st baking dish.

Serves 2.

Clojure 

(loop [[a b & more] (repeatedly #(rand-int 20))]
  (println a)
  (when-not (= 10 a) 
    (println b) 
    (recur more)))

COBOL

Works with: OpenCOBOL
       IDENTIFICATION DIVISION.
       PROGRAM-ID. Random-Nums.

       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01  Num  PIC Z9.

       PROCEDURE DIVISION.
       Main.
           PERFORM FOREVER
               PERFORM Generate-And-Display-Num

               IF Num = 10
                   EXIT PERFORM
               ELSE
                   PERFORM Generate-And-Display-Num
               END-IF
           END-PERFORM

           GOBACK
           .

       Generate-And-Display-Num.
           COMPUTE Num =  FUNCTION REM(FUNCTION RANDOM * 100, 20)
           DISPLAY Num
           .

CoffeeScript

We can use print from the Rhino JavaScript shell as in the JavaScript example or console.log, with a result like this: 

loop
  print a = Math.random() * 20 // 1  
  break if a == 10
  print Math.random() * 20 // 1

ColdFusion 

<Cfset randNum = 0>
<cfloop condition="randNum neq 10">
  <Cfset randNum = RandRange(0, 19)>
  <Cfoutput>#randNum#</Cfoutput>
  <Cfif randNum eq 10><cfbreak></Cfif>
  <Cfoutput>#RandRange(0, 19)#</Cfoutput>
  <Br>
</cfloop>
Output:

My first two test outputs (I swear this is true) 

6 0 
9 6 
12 3 
6 0 
14 10 
19 12 
18 14 
19 8 
3 2 
19 1 
11 12 
16 9 
11 15 
3 19 
13 8 
6 4 
4 4 
13 17 
16 9 
5 12 
12 6 
4 14 
1 10 
3 7 
11 15 
11 8 
0 16 
16 14 
8 14 
11 10 
8 8 
16 11 
4 7 
19 10 
8 2 
15 11 
18 10 
1 2 
18 9 
4 9 
6 6 
11 8 
14 6 
17 15 
13 2 
2 0 
2 17 
8 17 
18 13 
11 5 
15 18 
17 8 
15 3 
7 17 
7 13 
15 14 
11 9 
10

10

Common Lisp 

(loop for a = (random 20)
      do (print a)
      until (= a 10)
      do (print (random 20)))

Using DO

(do ((a (random 20) (random 20)))	; Initialize to rand and set new rand on every loop
    ((= a 10) (write a))		; Break condition and last step
  (format t "~a~3T~a~%" a (random 20)))	; On every loop print formated `a' and rand `b'
Output:
19 7
8  16
17 10
19 12
7  16
5  19
16 1
8  8
3  18
3  5
3  3
9  7
1  15
1  10
14 10
2  4
13 6
10

D 

import std.stdio, std.random;

void main() {
    while (true) {
        int r = uniform(0, 20);
        write(r, " ");
        if (r == 10)
            break;
        write(uniform(0, 20), " ");
    }
}
Output:
2 4 9 5 3 7 4 4 14 14 3 7 13 8 13 6 10

dc

Translation of: bc
1 ss  [s = seed of the random number generator]sz
0k    [scale = 0]sz

[Function r: Push a random number from 0 to 20.]sz
[
 [2Q]SA
 [
  [Formula (from POSIX) for random numbers of low quality.]sz
  ls 1103515245 * 12345 + 4294967296 % d ss  [Compute next s]sz
  65536 /     [it = s / 65536]sz
  d 16 !>A    [Break loop if 16 <= it]sz
  sz 0 0 =B   [Forget it, continue loop]sz
 ]SB 0 0 =B
 20 %         [Push it % 20]sz
 LA sz LB sz  [Restore A, B]sz
]sr


[2Q]sA
[
 0 0 =r p     [Print 1st number.]sz
 10 =A        [Break if 10 == it.]sz
 0 0 =r p sz  [Print 2nd number.]sz
 0 0 =B       [Continue loop.]sz
]sB 0 0 =B

Delphi 

program Project5;

{$APPTYPE CONSOLE}

var
  num:Integer;
begin
  Randomize;
  while true do
  begin
    num:=Random(20);
    Writeln(num);
    if num=10 then break;
  end;
end.

DWScript 

while True do begin
   var num := RandomInt(20);
   PrintLn(num);
   if num=10 then Break;
end;

E 

while (true) {
    def a := entropy.nextInt(20)
    print(a)
    if (a == 10) {
        println()
        break
    }
    println(" ", entropy.nextInt(20))
}

EasyLang 

repeat
  a = random 20
  print a
  until a = 10
  print random 20
.

Eiffel 

example
		-- Eiffel example code
	local
		n: INTEGER
		r: RANDOMIZER
	do
		from
			create r
			n := r.random_integer_in_range (0 |..| 19)
		until
			n = 10
		loop
			n := r.random_integer_in_range (0 |..| 19)
		end
	end
Output:

The output is superfluous and unneeded to read and understand what the Eiffel code is doing. The test code is sufficient to prove that it works. Uses randomizer library located at: https://github.com/ljr1981/randomizer

Ela

This implementation uses .NET Framework Math.Randomize function. Current ticks multiplied by an iteration index are used as a seed. As a result, an output looks almost truly random: 

open datetime random monad io
 
loop = loop' 1
       where loop' n t = do
                dt <- datetime.now
                seed <- return <| toInt <| (ticks <| dt) * n
                r <- return $ rnd seed 0 19
                putStrLn (show r)
                if r <> t then loop' (n + 1) t else return ()


loop 10 ::: IO

Elixir

Works with: Elixir version 1.2
defmodule Loops do
  def break, do: break(random)
  
  defp break(10), do: IO.puts 10
  defp break(r) do
    IO.puts "#{r},\t#{random}"
    break(random)
  end
  
  defp random, do: Enum.random(0..19)
end

Loops.break
Output:
13,     7
12,     7
2,      16
3,      19
17,     10
5,      17
14,     0
7,      6
5,      19
5,      12
4,      2
8,      14
1,      17
13,     5
10

Emacs Lisp 

(defun wait_10 ()
  (catch 'loop-break
    (while 't
      (let ((math (random 19)))
	(if (= math 10)
	    (progn  (message "Found value: %d" math)
		    (throw 'loop-break math))
	  (message "current number is: %d" math) ) ) ) ) )

(wait_10)

Erlang 

%% Implemented by Arjun Sunel
-module(forever).
-export([main/0, for/0]).
 
main() ->
	for().    
  	 
for() ->
	K = random:uniform(19),
        io:fwrite( "~p ", [K] ),
	if  K==10 ->
		ok;
	true ->
		M = random:uniform(19),
		io:format("~p~n",[M]),
   		for()
	end.

ERRE 

LOOP
    A=INT(RND(1)*20)
    PRINT(A)
    IF A=10 THEN EXIT LOOP END IF !EXIT FOR works the same inside FOR loops
    PRINT(INT(RND(1)*20))
END LOOP

The RND(X) function returns a random integer from 0 to 1. X is a dummy argument.

Euphoria 

integer i
while 1 do
    i = rand(20) - 1
    printf(1, "%g ", {i})
    if i = 10 then
        exit
    end if
    printf(1, "%g ", {rand(20)-1})
end while

The rand() function returns a random integer from 1 to the integer provided.

F# 

// Loops/Break. Nigel Galloway: February 21st., 2022
let n=System.Random()
let rec fN g=printf "%d " g; if g <> 10 then fN(n.Next(20))
fN(n.Next(20))

Factor

Using with-return: 

[
    [ 20 random [ . ] [ 10 = [ return ] when ] bi 20 random . t ] loop
] with-return

Idiomatic Factor: 

[ 20 random [ . ] [ 10 = not ] bi dup [ 20 random . ] when ] loop

Fantom 

class ForBreak
{
  public static Void main ()
  {
    while (true)
    {
      a := Int.random(0..19)
      echo (a)
      if (a == 10) break
      echo (Int.random(0..19))
    }
  }
}

Forth 

include random.fs

: main
  begin  20 random dup . 10 <>
  while  20 random .
  repeat ;

\ use LEAVE to break out of a counted loop
: main
  100 0 do
    i random dup .
    10 = if leave then
    i random .
  loop ;

Fortran

Works with: Fortran version 90 and later
program Example
  implicit none

  real :: r
  integer :: a, b

  do
     call random_number(r)
     a = int(r * 20)
     write(*,*) a
     if (a == 10) exit
     call random_number(r)
     b = int(r * 20)
     write(*,*) b
  end do

end program Example
Works with: Fortran version 77 and later
      PROGRAM LOOPBREAK
        INTEGER I, RNDINT

C       It doesn't matter what number you put here.
        CALL SDRAND(123)

C       Because FORTRAN 77 semantically lacks many loop structures, we
C       have to use GOTO statements to do the same thing.
   10   CONTINUE
C         Print a random number.
          I = RNDINT(0, 19)
          WRITE (*,*) I

C         If the random number is ten, break (i.e. skip to after the end
C         of the "loop").
          IF (I .EQ. 10) GOTO 20

C         Otherwise, print a second random number.
          I = RNDINT(0, 19)
          WRITE (*,*) I

C         This is the end of our "loop," meaning we jump back to the
C         beginning again.
          GOTO 10

   20   CONTINUE

        STOP
      END

C FORTRAN 77 does not come with a random number generator, but it
C is easy enough to type "fortran 77 random number generator" into your
C preferred search engine and to copy and paste what you find. The
C following code is a slightly-modified version of:
C
C     http://www.tat.physik.uni-tuebingen.de/
C         ~kley/lehre/ftn77/tutorial/subprograms.html
      SUBROUTINE SDRAND (IRSEED)
        COMMON  /SEED/ UTSEED, IRFRST
        UTSEED = IRSEED
        IRFRST = 0
        RETURN
      END
      INTEGER FUNCTION RNDINT (IFROM, ITO)
        INTEGER IFROM, ITO
        PARAMETER (MPLIER=16807, MODLUS=2147483647,                     &
     &              MOBYMP=127773, MOMDMP=2836)
        COMMON  /SEED/ UTSEED, IRFRST
        INTEGER HVLUE, LVLUE, TESTV, NEXTN
        SAVE    NEXTN
        IF (IRFRST .EQ. 0) THEN
          NEXTN = UTSEED
          IRFRST = 1
        ENDIF
        HVLUE = NEXTN / MOBYMP
        LVLUE = MOD(NEXTN, MOBYMP)
        TESTV = MPLIER*LVLUE - MOMDMP*HVLUE
        IF (TESTV .GT. 0) THEN
          NEXTN = TESTV
        ELSE
          NEXTN = TESTV + MODLUS
        ENDIF
        IF (NEXTN .GE. 0) THEN
          RNDINT = MOD(MOD(NEXTN, MODLUS), ITO - IFROM + 1) + IFROM
        ELSE
          RNDINT = MOD(MOD(NEXTN, MODLUS), ITO - IFROM + 1) + ITO + 1
        ENDIF
        RETURN
      END
Works with: Fortran version 66 and earlier

Anyone who attempts to produce random numbers via a computation is already in a state of sin, so, one might as well be hung as a goat rather than as a lamb. Here is a version using the RANDU generator, in the style of Fortran 66 as offered by the IBM1130. No logical-if statements and reliance on implicit type declarations. Sixteen-bit integers result. The standard advice is to start IX off as an odd number. Note that RANDU does not update IX (the "seed"); the caller must do so. Since integer overflow producing negative numbers is undone by adding 32768 (trusting that the compiler will not attempt to combine constants, thus + 32767 + 1) in the absence of an AND operation, possible values for IY are presumably zero to 32767. Since IY is divided by 32767.0 (not 32768.0 for example), the range for YFL is zero to one inclusive, though further inspection shows that zero is not attained for proper starts - should IX be zero it will never change, thus the span is (0,1]; a more common arrangement is [0,1).

Because the upper bound is attainable, multiplying YFL by 19 and truncating the result will mean that 19 appears only as an edge event when IY = 32767. Multiplying by 20 will ensure that 19 gets its fair share along with each other integer, but, the edge event might now occasionally produce a 20. There is no MIN function available, so, explicit testing results. Rather than repeat this code with its consequent litter of labels, a helper function IR19 does the work once. These out-by-one opportunities are vexing.

The RANDU routine is so notorious that latter-day compilers can supply their own RANDU (using a better method), and further, disregard a user-supplied RANDU routine so it may have to be called RANDUU or some other name! 

      SUBROUTINE RANDU(IX,IY,YFL)
Copied from the IBM1130 Scientific Subroutines Package (1130-CM-02X): Programmer's Manual, page 60.
CAUTION! This routine's 32-bit variant is reviled by Prof. Knuth and many others for good reason!
        IY = IX*899
        IF (IY) 5,6,6
    5   IY = IY + 32767 + 1
    6   YFL = IY
        YFL = YFL/32767.
      END

      FUNCTION IR19(IX)
        CALL RANDU(IX,IY,YFL)
        IX = IY
        I = YFL*20
        IF (I - 20) 12,11,11
   11   I = 19
   12   IR19 = I
      END

      IX = 1
Commence the loop.
   10 I = IR19(IX)
      WRITE (6,11) I
   11 FORMAT (I3)
      IF (I - 10) 12,20,12
   12 I = IR19(IX)
      WRITE (6,11) I
      GO TO 10
Cease.
   20 CONTINUE
      END

Output, converted to along the line: 

 0 13  4 19  1  7  2 12  4  7 14 11  6  4  0  9  5 12 16 19 18  2  0 13  2  7 10

This source will compile with later compilers (possibly after adding INTEGER*2 declarations to not use larger integers), as well as earlier compilers. But the IBM1620's Fortran II ran on a decimal computer (and the compiler allowed an option to specify how many digits in a number) so the assumption of sixteen-bit two's-complement arithmetic would fail. There was once much more variety in computer design, not just always a power of two in word sizes.

FreeBASIC 

' FB 1.05.0 Win64

Dim i As Integer
Randomize
Do
  i = Int(Rnd * 20)
  Print Using "##"; i; 
  Print "  ";
  If i = 10 Then Exit Do
  i = Int(Rnd * 20)
  Print Using "##"; i; 
  Print"  ";
Loop

Print
Sleep

Sample output

Output:
 6  12   2  16   5  19   9   6  16   1  16  10   1   4  18   3   2   9  19   0
19  13   0   0  12  17  13  12  18  10   8  13   9   5  14   7  10

Frink 

while true
{
   a = random[0,19]
   print["$a "]
   if a == 10
      break

   b = random[0,19]
   print["$b "]
}
Output:
3 8 8 8 11 6 3 2 10

FutureBasic 

include "NSLog.incl"

long num
do
num = rnd(20) - 1
NSLog(@"%ld",num)
until ( num == 10 )

HandleEvents

Gambas 

Public Sub Form_Open()
Dim iRand As Integer

Repeat
  iRand = Rnd * 20
  Print iRand
Until iRand = 10

End

==Gambas ==

Click this link to run this code 

Public Sub Main()
Dim byNo As Byte

Do
  byNo = Rand(0, 19)
  Print byNo;;
  If byNo = 10 Then Break
  byNo = Rand(0, 19)
  Print byNo;;
Loop

End

Output: 

0 5 12 8 1 13 16 5 4 11 5 7 15 12 16 7 9 10 13 19 4 10 2 13 16 7 0 1 16 3 17 10 0 16 14 0 0 8 6 2 1 5 9 12 2 18 15 1 1 17 9 18 8 17 19 12 6 19 9 5 15 1 2 7 2 11 18 1 15 19 10

GAP 

while true do
    a := Random(0, 19);
    Print(a);
    if a = 10 then
        Print("\n");
        break;
    fi;
    a := Random(0, 19);
    Print("\t", a, "\n");
od;

# 11      6
# 5       8
# 1       4
# 5       10
# 1       16
# 10

GML 

while(1)
    {
    a = floor(random(19))
    show_message(string(a))
    if(a = 10)
        break
    b = floor(random(19))
    show_message(string(a))
    }

Go 

package main

import "fmt"
import "math/rand"
import "time"

func main() {
    rand.Seed(time.Now().UnixNano())
    for {
        a := rand.Intn(20)
        fmt.Println(a)
        if a == 10 {
            break
        }
        b := rand.Intn(20)
        fmt.Println(b)
    }
}

Groovy 

final random = new Random()

while (true) {
    def random1 = random.nextInt(20)
    print random1
    if (random1 == 10) break
    print '     '
    println random.nextInt(20)
}

GW-BASIC 

10 NUM = 0
20 WHILE NUM <> 10
30     NUM = INT(RND * 20)
40     PRINT NUM
50 WEND

Harbour 

PROCEDURE Loop()

   LOCAL n

   DO WHILE .T.
      ? n := hb_RandomInt( 0, 19 )
      IF n == 10
         EXIT
      ENDIF
      ? hb_RandomInt( 0, 19 )
   ENDDO

   RETURN

Haskell 

import Control.Monad
import System.Random

loopBreak n k = do 
  r <- randomRIO (0,n)
  print r
  unless (r==k) $ do
    print =<< randomRIO (0,n)
    loopBreak n k

Use: 

loopBreak 19 10

Haxe 

class Program {
  static public function main():Void {
    while(true) {
      var a = Std.random(20);
      Sys.println(a);
      if (a == 10)
        break;
      var b = Std.random(20);
      Sys.println(b);
    }
  }
}

hexiscript 

while true
  let r rand 20
  println r
  if r = 10
    break
  endif
  println rand 20
endwhile

HicEst 

1  DO i = 1, 1E20 ! "forever"
     a = INT( RAN(10, 10) )
     WRITE(name) a
     IF( a == 10) GOTO 10
     b = INT( RAN(10, 10) )
     WRITE(name) b
   ENDDO
10
 END

HolyC 

U16 a, b;
while (1) {
  a = RandU16 % 20;
  Print("%d\n", a);

  if (a == 10) break;

  b = RandU16 % 20;
  Print("%d\n", b);
}

Icon and Unicon 

procedure main()
    while 10 ~= writes(?20-1) do write(", ",?20-1)
end

Notes:

  • For any positive integer i, ?i produces a value j where 1 <= j <= i
  • Although this can be written with a break (e.g. repeat expression & break), there is no need to actually use one. (And it's ugly).
  • Programmers new to Icon/Unicon need to understand that just about everything returns values including comparison operators, I/O functions like write/writes.
  • This program will perform similarly but not identically under Icon and Unicon because the random operator ?i behaves differently. While both produce pseudo-random numbers a different generator is used. Also, the sequence produced by Icon begins with the same seed value and is repeatable whereas the sequence produced by Unicon does not. One way to force Icon to use different random sequences on each call would be to add the line 
    &random := integer(map("smhSMH","Hh:Mm:Ss",&clock))
    at the start of the main procedure to set the random number seed based on the time of day.

Io 

loop(
    a := Random value(0,20) floor
    write(a)
    if( a == 10, writeln ; break)
    b := Random value(0,20) floor
    writeln(" ",b)
)

J 

loopexample=: {{
  while. do.
    echo k=. ?20
    if. 10=k do. return. end.
    echo ?20
  end.
}}

Note that break. or goto_FOO. could have been used in place of return.: 

loopexample2=: verb define
  while. do.
    echo k=. ?20
    if. 10=k do. break. end.
    echo ?20
  end.
)

loopexample3=: {{
  while. do.
    echo k=. ?20
    if. 10=k do. goto_done. end.
    echo ?20
  end.
  label_done.
}}

Java 

import java.util.Random;

Random rand = new Random();
while(true){
    int a = rand.nextInt(20);
    System.out.println(a);
    if(a == 10) break;
    int b = rand.nextInt(20);
    System.out.println(b);
}

JavaScript 

for (;;) {
  var a = Math.floor(Math.random() * 20);
  print(a);
  if (a == 10) 
    break;
  a = Math.floor(Math.random() * 20);
  print(a);
}

The print() function is available in the Rhino JavaScript shell.


If we step back for a moment from imperative assumptions about repetitive processes and their interruption, we may notice that there is actually no necessary connection between repetitive process and loops.

In a functional idiom of JavaScript, we might instead write something like: 

(function streamTillInitialTen() {
    var nFirst = Math.floor(Math.random() * 20);
        
    console.log(nFirst);
    
    if (nFirst === 10) return true;
    
    console.log(
        Math.floor(Math.random() * 20)
    );
    
    return streamTillInitialTen();
})();

Obtaining runs like: 

18
10
16
10
8
0
13
3
2
14
15
17
14
7
10
8
0
2
0
2
5
16
3
16
6
7
19
0
16
9
7
11
17
10

Though returning a value composes better, and costs less IO traffic, than firing off side-effects from a moving thread: 

console.log(
  (function streamTillInitialTen() {
    var nFirst = Math.floor(Math.random() * 20);
  
    if (nFirst === 10) return [10];
  
    return [
      nFirst,
      Math.floor(Math.random() * 20)
    ].concat(
      streamTillInitialTen()
    );
  })().join('\n')
);

Sample result: 

17
14
3
4
13
10
15
5
10

jq

With the functions defined below, the task can be accomplished using the following jq filter: 

   take( rand(20); . != 10 )

Here, `rand(n)` is a pseudo-random number generator, and `take(stream; cond)` will continue taking from the stream so long as the condition is satisfied. When the condition is no longer satisfied, the PRNG is immediately terminated.

Using the built-in `foreach` construct, the above is equivalent to: 

   label $done | foreach rand(20) as $n (null; $n; if . == 10 then break $done else . end)

PRNG

Currently, jq does not have a built-in random-number generator, so here we borrow one of the linear congruential generators defined at https://rosettacode.org/wiki/Linear_congruential_generator - 

# 15-bit integers generated using the same formula as rand() 
# from the Microsoft C Runtime.
# Input: [ count, state, rand ]
def next_rand_Microsoft:
  .[0] as $count | .[1] as $state
  | ( (214013 * $state) + 2531011) % 2147483648 # mod 2^31
  | [$count+1 , ., (. / 65536 | floor) ];
 
def rand_Microsoft(seed):
  [0,seed]
  | next_rand_Microsoft  # the seed is not so random
  | recurse( next_rand_Microsoft )
  | .[2];

# Generate random integers from 0 to (n-1):
def rand(n): n * (rand_Microsoft(17) / 32768) | trunc;

"take" 

def take(s; cond):
  label $done
  | foreach s as $n (null; $n; if $n | cond | not then break $done else . end);

"count"

Since the PRNG used here is deterministic, we'll just count the number of integers generated: 

def count(s): reduce s as $i (0; . + 1);

Example 

   count(take(rand(20); . != 10))
Output:
   12

Julia 

while true
    n = rand(0:19)
    @printf "%4d" n
    if n == 10
        println()
        break
    end
    n = rand(0:19)
    @printf "%4d\n" n
end
Output:
   0  11
  11   7
   4  19
   7  19
   5   2
   5  17
  12   5
  14  18
   1  10
  18  14
  16   0
  17   1
  10

Kotlin

Translation of: Java
import java.util.Random

fun main(args: Array<String>) {
    val rand = Random()
    while (true) {
        val a = rand.nextInt(20)
        println(a)
        if (a == 10) break
        println(rand.nextInt(20))
    }
}

Lambdatalk 

{def loops_break
 {lambda {:n}
  {if {= :n 10}
   then :n -> end of loop
   else :n {loops_break {round {* 20 {random}}}}}}}
-> loops_break 

{loops_break 0} 
-> 0 16 8 5 9 17 9 18 1 18 1 1 12 13 15 1 10 -> end of loop

Lang5 

do 20 ? int dup . 10 == if break then 20 ? int . loop

langur 

for {
    val .i = random 0..19
    write .i, " "
    if .i == 10 { writeln(); break }
    write random(0..19), " "
}
Output:
13 18 14 8 0 5 17 13 9 13 6 5 13 16 6 9 11 18 10

Lasso 

local(x = 0)
while(#x != 10) => {^
	#x = integer_random(19,0)
	#x
	#x == 10 ? loop_abort
	', '+integer_random(19,0)+'\r'
^}

Liberty BASIC

The task specifies a "number". 

while num<>10
    num=rnd(1)*20
    print num
    if num=10 then exit while
    print rnd(1)*20
wend

If "integer" was meant, this code fulfils that requirement. 

while num<>10
    num=int(rnd(1)*20)
    print num
    if num=10 then exit while
    print int(rnd(1)*20)
wend

Lingo 

repeat while TRUE
  n = random(20)-1
  put n
  if n = 10 then exit repeat
  put random(20)-1
end repeat

Lisaac 

Section Header

+ name := TEST_LOOP_BREAK;

Section Public

- main <- (
  + a, b : INTEGER;

  `srand(time(NULL))`;
  {
    a := `rand()`:INTEGER % 20; // not exactly uniformly distributed, but doesn't matter
    a.print;
    '\n'.print;
    a == 10
  }.until_do {
    b := `rand()`:INTEGER % 20; // not exactly uniformly distributed, but doesn't matter
    b.print;
    '\n'.print;
  }
);

LiveCode 

command loopForeverRandom
    repeat forever
        put random(20) - 1 into tRand
        put tRand
        if tRand is 10 then exit repeat
        put random(20) - 1
    end repeat
end loopForeverRandom

Lua 

repeat
  k = math.random(19)
  print(k)
  if k == 10 then break end
  print(math.random(19)
until false

M2000 Interpreter

We use block of module to loop. Break also can be used, but breaks nested blocks (without crossing modules/functions). Using break in second Checkit module we break three blocks. 

Module Checkit {
      M=Random(0, 19)
      Print M
      If M=10 then Continue  ' because loop flag is false, continue act as Exit
      Print Random(0, 19)
      loop
}
Checkit

Module Checkit {
      do {
            do {
                  {
                        M=Random(0, 19)
                        Print M
                        If M=10 then Break
                        Print Random(0, 19)
                        loop
                  }     
                  Print "no print this" 
            } always
            Print "no print this"
      } always
      Print "print ok"
}
Checkit

M4 

define(`randSeed',141592653)dnl
define(`setRand',
   `define(`randSeed',ifelse(eval($1<10000),1,`eval(20000-$1)',`$1'))')dnl
define(`rand_t',`eval(randSeed^(randSeed>>13))')dnl
define(`random',
   `define(`randSeed',eval((rand_t^(rand_t<<18))&0x7fffffff))randSeed')dnl
dnl
define(`loopbreak',`define(`a',eval(random%20))`a='a
ifelse(a,10,`',`define(`b',eval(random%20))`b='b
loopbreak')')dnl
dnl
loopbreak
Output:
a=17
b=3
a=0
b=15
a=10

Maple 

r := rand( 0 .. 19 ):
do
        n := r();
        printf( "%d\n", n );
        if n = 10 then
                break
        end if;
        printf( "%d\n", r() );
end do:

Mathematica /Wolfram Language 

While[(Print[#];#!=10)&[RandomIntger[{0,19}]],
         Print[RandomInteger[{0,19}]
        ]

Maxima 

/* To exit the innermost block, use return(<value>) */

block([n],
   do (
      n: random(20),
      ldisp(n),
      if n = 10 then return(),
      n: random(20),
      ldisp(n)
   )
)$

/* To exit any level of block, use catch(...) and throw(<value>);
they are not used for catching exceptions, but for non-local
return. Use errcatch(...) for exceptions. */

block([n],
   catch(
      do (
         n: random(20),
         ldisp(n),
         if n = 10 then throw('done),
         n: random(20),
         ldisp(n)
      )
   )
)$

/* There is also break(<value>, ...) in Maxima. It makes Maxima
stop the evaluation and enter a read-eval loop where one can change
variable values, then return to the function after exit; For example */

block([x: 1], break(), ldisp(x));
> x: 2;
> exit;
2

MAXScript 

while true do
(
	a = random 0 19
	format ("A: % \n") a
	if a == 10 do exit
	b = random 0 19
	format ("B: % \n") b
)

min

Works with: min version 0.19.6
randomize
(19 random puts 10 ==) (19 random puts!) () () linrec

МК-61/52 

СЧ	2	0	*	П0
1	0	-	[x]	x#0	18
СЧ	2	0	*	П1
БП	00	ИП0	С/П

Modula-3 

MODULE Break EXPORTS Main;

IMPORT IO, Fmt, Random;

VAR a,b: INTEGER;

BEGIN
  WITH rand = NEW(Random.Default).init() DO
    LOOP
      a := rand.integer(min := 0, max := 19);
      IO.Put(Fmt.Int(a) & "\n");
      IF a = 10 THEN EXIT END;
      b := rand.integer(min := 0, max := 19);
      IO.Put(Fmt.Int(b) & "\n");
    END;
  END;
END Break.

MOO 

while (1)
  a = random(20) - 1;
  player:tell(a);
  if (a == 10)
    break;
  endif
  b = random(20) - 1;
  player:tell(b);
endwhile

MUMPS 

BREAKLOOP
 NEW A,B
 SET A=""
 FOR  Q:A=10  DO
 .SET A=$RANDOM(20)
 .WRITE !,A
 .Q:A=10
 .SET B=$RANDOM(20)
 .WRITE ?6,B
 KILL A,B
 QUIT
 ;A denser version that doesn't require two tests
 NEW A,B 
 FOR  SET A=$RANDOM(20) WRITE !,A QUIT:A=10  SET B=$RANDOM(20) WRITE ?6,B
 KILL A,B QUIT
Output:
USER>D BREAKLOOP^ROSETTA
 
5     3
9     13
3     12
9     19
16    4
11    17
18    2
4     18
10
USER>D BREAKLOOP+11^ROSETTA
 
6     13
15    3
0     8
8     18
7     13
15    10
15    13
10

Neko 

/**
 Loops/Break in Neko
 Tectonics:
   nekoc loops-break.neko
   neko loops-break
*/

var random_new = $loader.loadprim("std@random_new", 0);
var random_int = $loader.loadprim("std@random_int", 2);

var random = random_new();

while true {
  var r = random_int(random, 20);
  $print(r, " ");

  if r == 10 break;

  r = random_int(random, 20);
  $print(r, " ");
}
$print("\n");
Output:
prompt$ nekoc loops-break.neko
prompt$ neko loops-break
0 8 17 12 4 18 7 6 19 11 13 6 12 7 6 6 6 18 14 7 18 10 15 6 9 5 4 14 10

Nemerle

Translation of: C#
using System;
using System.Console;
using Nemerle.Imperative;

module Break
{
    Main() : void
    {
        def rnd = Random();
        while (true)
        {
            def a = rnd.Next(20);
            WriteLine(a);
            when (a == 10) break;
            def b = rnd.Next(20);
            WriteLine(b);
        }
    }
}

NetRexx 

/* NetRexx */
options replace format comments java crossref savelog symbols nobinary

  say
  say 'Loops/Break'
  rn = Rexx
  rnd = Random()

  loop label lb forever
    rn = rnd.nextInt(19)
    say rn.right(3)'\-'
    if rn = 10 then leave lb
    rn = rnd.nextInt(19)
    say rn.right(3)'\-'
    end lb
  say

NewLISP 

(until (= 10 (println (rand 20)))
  (println (rand 20)))

Nim

Translation of: Python
import random

while true:
  let a = random(19)
  echo a
  if a == 10:
    break
  let b = random(19)
  echo b

NS-HUBASIC 

10 I=RND(20)
20 PRINT I
30 IF I=10 THEN STOP
40 PRINT RND(20)
50 GOTO 10

Oberon-2

Works with oo2c Version 2 

MODULE LoopBreak;
IMPORT
  RandomNumbers,
  Out;

PROCEDURE Do();
VAR
  rn: LONGINT;
BEGIN
  LOOP
    rn := RandomNumbers.RND(20);
    Out.LongInt(rn,0);Out.Ln;
    IF rn = 10 THEN EXIT END;
    rn := RandomNumbers.RND(20);
    Out.LongInt(rn,0);Out.Ln
  END
END Do;

BEGIN
  Do
END LoopBreak.

Objeck 

while(true) {
  a := (Float->Random() * 20.0)->As(Int);
  a->PrintLine();
  if(a = 10) { 
    break;
  };
  a := (Float->Random() * 20.0)->As(Int);
  a->PrintLine();
}

OCaml 

# Random.self_init();;
- : unit = ()

# while true do
    let a = Random.int 20 in
    print_int a;
    print_newline();
    if a = 10 then raise Exit;
    let b = Random.int 20 in
    print_int b;
    print_newline()
  done;;
15
18
2
13
10
Exception: Pervasives.Exit.

Octave 

while(1)
  a = floor(unifrnd(0,20, 1));
  disp(a)
  if ( a == 10 )
    break
  endif
  b = floor(unifrnd(0,20, 1));
  disp(b)
endwhile

Oforth 

while(true) [
      19 rand dup print ":" print
      10 == ifTrue: [ break ]
      19 rand print " " print
   ]

Ol 

(import (otus random!))

(call/cc (lambda (break)
   (let loop ()
      (if (= (rand! 20) 10)
         (break #t))
      (print (rand! 20))
      (loop))))

ooRexx 

/*REXX ****************************************************************
* Three Ways to leave a Loop
* ooRexx added the possibility to leave an outer loop
* without using a control variable
* 12.05.2013 Walter Pachl
**********************************************************************/
do i1=1 To 2                           /* an outer loop              */
  Say 'i1='i1                          /* tell where we are          */
  Call random ,,123                    /* seed to be reproducable    */
  do forever                           /* inner loop                 */
    a=random(19)
    Say a
    if a=6  then leave                 /* leaces the innermost loop  */
    end
  end

do i2=1 To 2
  Say 'i2='i2
  Call random ,,123
  do forever
    a=random(19)
    Say a
    if a=6  then leave i2    /* leaves loop with control variable i2 */
    end
  end

Parse Version v
Select
  When pos('ooRexx',v)>0 Then supported=1
  Otherwise                   supported=0
  End
If supported Then Do
  Say 'Leave label-name is supported in' v
do Label i3 Forever
  Say 'outer loop'
  Call random ,,123
  do forever
    a=random(19)
    Say a
    if a=6  then leave i3          /* leaves loop with label name i3 */
    end
  end
End
Else
  Say 'Leave label-name is probably not supported in' v
Output:
i1=1
14
14
5
6
i1=2
14
14
5
6
i2=1
14
14
5
6
Leave label-name is supported in REXX-ooRexx_4.1.2(MT) 6.03 28 Aug 2012
outer loop
14
14
5
6

Oz

We can implement this either with recursion or with a special type of the for-loop. Both can be considered idiomatic. 

for break:Break do
   R = {OS.rand} mod 20
in
   {Show R}
   if R == 10 then {Break}
   else {Show {OS.rand} mod 20}
   end
end

PARI/GP 

while(1,
  t=random(20);
  print(t);
  if(t==10, break);
  print(random(20))
)

Pascal

See Delphi

Perl 

while (1) {
    my $a = int(rand(20));
    print "$a\n";
    if ($a == 10) {
        last;
    }
    my $b = int(rand(20));
    print "$b\n";
}

Phix

Library: Phix/basics
Translation of: Euphoria

The rand() function returns a random integer from 1 to the integer provided. 

integer i
while 1 do
    i = rand(20)-1
    printf(1, "%g ", {i})
    if i=10 then exit end if
    printf(1, "%g\n", {rand(20)-1})
end while
Output:
2 10
1 7
3 16
10

Phixmonti 

/# Rosetta Code problem: https://rosettacode.org/wiki/Loops/Break
by Galileo, 11/2022 #/

include ..\Utilitys.pmt

def ran rand * int enddef

true while
    20 ran
    dup print "\t" print
    10 == if false else 20 ran ? true endif
endwhile
Output:
12      8
12      10
5       7
10
=== Press any key to exit ===

PHP 

while (true) {
    $a = rand(0,19);
    echo "$a\n";
    if ($a == 10)
        break;
    $b = rand(0,19);
    echo "$b\n";
}

PicoLisp

Literally: 

(use R
   (loop
      (println (setq R (rand 1 19)))
      (T (= 10 R))
      (println (rand 1 19)) ) )

Shorter: 

(until (= 10 (println (rand 1 19)))
   (println (rand 1 19)) )

Pike 

int main(){
   while(1){
      int a = random(20);
      write(a + "\n");
      if(a == 10){
         break;
      }
      int b = random(20);
      write(b + "\n");
   }
}

PL/I 

do forever;
   k = trunc(random()*20);
   put (k);
   if k = 10 then leave;
   k = trunc(random()*20);
   put skip list (k);
end;

Plain English 

To run:
Start up.
Demonstrate breaking.
Wait for the escape key.
Shut down.

To demonstrate breaking:
Pick a number between 0 and 19.
Write the number to the console.
If the number is 10, break.
Pick another number between 0 and 19.
Write the other number to the console.
Repeat.

To write a number to the console:
Convert the number to a string.
Write the string to the console.

PostScript 

realtime srand          % init RNG
{
    rand 20 mod         % generate number between 0 and 19
    dup =               % print it
    10 eq { exit } if   % exit if 10
} loop

PowerShell 

$r = New-Object Random
for () {
    $n = $r.Next(20)
    Write-Host $n
    if ($n -eq 10) {
        break
    }
    Write-Host $r.Next(20)
}

PureBasic 

If OpenConsole()

  Repeat
    a = Random(19)
    PrintN(Str(a))
    If a = 10
      Break
    EndIf 
    b = Random(19)
    PrintN(Str(b))
    PrintN("")
  ForEver

  Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
  Input()
  CloseConsole()
EndIf

Python 

from random import randrange

while True:
    a = randrange(20)
    print(a)
    if a == 10:
        break
    b = randrange(20)
    print(b)

QB64

CBTJD: 2020/03/14 

RANDOMIZE TIMER
DO
    n = INT(RND * 20)
    PRINT n,
    IF n = 10 THEN
        EXIT DO
    ELSE
        n = INT(RND * 20)
        PRINT n
    END IF
LOOP UNTIL 0

Qi 

(define loop -> (if (= 10 (PRINT (random 20)))
                    true
                    (do (PRINT (random 20))
                        (loop))))
(loop)

Quackery 

[ 20 random
  dup echo sp 
  10 = if done
  20 random echo cr
  again ]
Output:
16 9
9 14
11 16
14 13
14 17
16 19
13 11
10


R

Works with: R version 2.8.1
sample0to19 <- function() sample(0L:19L, 1,replace=TRUE)
repeat
{
  result1 <- sample0to19()
  if (result1 == 10L)
  {
    print(result1)
    break
  }
  result2 <- sample0to19()
  cat(result1, result2, "\n")
}

Racket 

#lang racket
(let loop ()
  (let/ec break
    (define a (random 20))
    (displayln a)
    (when (= a 10) (break))
    (displayln (random 20))
    (loop)))

Raku

(formerly Perl 6)

Works with: Rakudo version #21 "Seattle"
loop {
    say my $n = (0..19).pick;
    last if $n == 10;
    say (0..19).pick;
}

REBOL 

REBOL [
	Title: "Loop/Break"
	URL: http://rosettacode.org/wiki/Loop/Break
]

random/seed 1 ; Make repeatable.
; random/seed now ; Uncomment for 'true' randomness.

r20: does [(random 20) - 1]

forever [
	prin x: r20
	if 10 = x [break]
	print rejoin [" " r20]
]
print ""
Output:
14 11
19 15
6 11
12 11
3 14
10

Red

Translation of: REBOL
Red [
    Title: "Loops/Break"
    URL: http://rosettacode.org/wiki/Loops/Break
]

random/seed 2 ; Make repeatable. Delete line for 'true' randomness.

r20: does [(random 20) - 1]

forever [
    prin x: r20
    if 10 = x [break]
    print rejoin [" " r20]
]
print ""
Output:
2 15
0 0
1 11
6 14
4 14
10

Retro 

doc{
A couple of helper functions to make the rest of the
code more readable.
}doc

: rand  ( -n )  random 20 mod ;
: .  ( n- )  putn space ;

doc{
One approach is to use a simple repeat/again loop, and
a conditional exit. For instance:
}doc

: foo   ( - )
  repeat rand dup . 10 = if; rand . again ;

doc{
The other approach uses a structured while loop with the
second printing handled by a conditional clause.
}doc

[ rand dup . 10 <> [ [ rand . ] ifTrue ] sip ] while

REXX 

/*REXX program demonstrates a    FOREVER   DO  loop  with a test to    LEAVE   (break). */
                                                 /*REXX's RANDOM BIF returns an integer.*/
    do forever                                   /*perform loop until da cows come home.*/
    a=random(19)                                 /*same as:    random(0, 19)            */
    call charout , right(a, 5)                   /*show   A   right─justified, column 1.*/
    if a==10  then leave                         /*is random #=10?  Then cows came home.*/
    b=random(19)                                 /*same as:    random(0, 19)            */
    say right(b, 5)                              /*show   B   right─justified, column 2.*/
    end   /*forever*/                            /* [↑]  CHAROUT , xxx   writes to term.*/
                                                 /*stick a fork in it,  we're all done. */
output:

(A long run was chosen) 

    1    0
   16    3
    8   15
   11    8
   12   14
   15    4
    0    0
    6   11
   15    5
   14    0
   18   16
   15    0
   14    5
    3    5
    9    4
    4    4
   17    6
    4   10
    6    2
    9   13
   12    6
   14   16
   17    0
    8    6
    9    2
    0    6
    9    9
   12    8
   11    3
   11    4
    7    1
    3   13
    4    8
   14   14
   14   13
   12    7
    1    0
   16   15
    8   19
   12    7
   18    9
    7   18
   19   13
    6    2
    6    7
    2    1
    8    2
    9    7
    6   13
   19   15
   10

Ring 

while true
      a = random(20)
      see a + nl
      if a = 10 exit ok
end

Ruby 

loop do
  a = rand(20)
  print a
  if a == 10
    puts
    break
  end
  b = rand(20)
  puts "\t#{b}"
end

or 

loop do
  print a = rand(20)
  puts or break if a == 10
  puts "\t#{rand(20)}"
end
Output:
0       4
11      0
8       2
12      13
3       0
6       9
2       8
12      10
8       17
12      6
10

Rust

Library: rand
// cargo-deps: rand

extern crate rand;
use rand::{thread_rng, Rng};
 
fn main() {
    let mut rng = thread_rng();
    loop {
        let num = rng.gen_range(0, 20);
        if num == 10 {
            println!("{}", num);
            break;
        }
        println!("{}", rng.gen_range(0, 20));
    }
}

SAS 

data _null_;
do while(1);
   n=floor(uniform(0)*20);
   put n;
   if n=10 then leave;    /* 'leave' to break a loop */
end;
run;

Sather 

-- help class for random number sequence
class RANDOM is
  attr seed:INT;

  create(seed:INT):SAME is
    res:RANDOM := new;
    res.seed := seed;
    return res;
  end;
  -- this code is taken from rand's man (C)
  next:INT is
    seed := seed * 1103515245 + 12345;
    return (seed/65536) % 32768;
  end;
end;

class MAIN is
  main is
    a, b :INT;
    rnd:RANDOM := #(1);
    loop
      a := rnd.next % 20;
      #OUT + a + "\n";
      if a = 10 then break!; end; -- here we break
      b := rnd.next % 20;
      #OUT + b + "\n";
    end; 
  end;
end;

Scala 

scala> import util.control.Breaks.{breakable, break}
import util.control.Breaks.{breakable, break}

scala> import util.Random
import util.Random

scala> breakable {
     |   while(true) {
     |     val a = Random.nextInt(20)
     |     println(a)
     |     if(a == 10)
     |       break
     |     val b = Random.nextInt(20)
     |     println(b)
     |   }
     | }
5
4
10

Scheme 

(let loop ((first (random 20)))
  (print first)
  (if (not (= first 10))
      (begin
        (print (random 20))
        (loop (random 20)))))

Or by using call/cc to break out: 

(call/cc 
 (lambda (break)
   (let loop ((first (random 20)))
     (print first)
     (if (= first 10)
         (break))
     (print (random 20))
     (loop (random 20)))))

Scilab

Works with: Scilab version 5.5.1
while %T
    a=int(rand()*20)  // [0..19] 
    printf("%2d ",a)
    if a==10 then break; end
    b=int(rand()*20)
    printf("%2d\n",b)
end
printf("\n")
Output:
 4 15
 0  6
13 12
16 13
17  1
11 13
14  3
10

Seed7

Seed7 has no goto statement and hidden gotos like break- and continue-statements are also omitted. But this is not a problem. All programs with break-statements can be rewritten as structured programs without break. Usually structured programs have better readability. If you are used to it writing programs without goto (and break) is easy. The example below shows how easy a break can be avoided in this exercise. The loop ends, if the first random number is 10. The second random number does never terminate the loop. 

$ include "seed7_05.s7i";

const proc: main is func
  local
    var integer: number is 0;
  begin
    repeat
      number := rand(0, 19);
      writeln(number);
      if number <> 10 then
        writeln(rand(0, 19));
      end if;
    until number = 10;
  end func;

Sidef 

var lim = 20;
loop {
    say (var n = lim.rand.int);
    n == 10 && break;
    say lim.rand.int;
}

Simula

Works with: SIMULA-67
! Loops/Break - simula67 - 08/03/2017;
begin
  integer num,seed;
  seed:=0;
  while true do
  begin
    num:=randint(1,20,seed);
    outint(num,2); outimage;
    if num=10 then goto lab;
  end;
lab:
end
Output:
 1
 9
 8
10

Smalltalk

Works with: Smalltalk/X
[
    |first second done|

    first := Random nextIntegerBetween:0 and:19.
    Stdout print:first; cr.
    (done := (first == 10)) ifFalse:[
        second := Random nextIntegerBetween:0 and:19.
        Stdout print:' '; print:second; cr.
    ].
    done
] whileFalse

alternative: 

[:exit |
    |first|

    Stdout printCR: (first := Random nextIntegerBetween:0 and:19).
    first == 10 ifTrue:[ exit value:nil ].
    Stdout print:' '; printCR: (Random nextIntegerBetween:0 and:19).
] loopWithExit.

or shorter (because ifTrue: sends #value to its arg): 

[:exit |
    |first|

    Stdout printCR: (first := Random nextIntegerBetween:0 and:19).
    first == 10 ifTrue:exit.
    Stdout print:' '; printCR: (Random nextIntegerBetween:0 and:19).
] loopWithExit.

Snabel

Uses a ranged random generator as iterator. 

let: rnd 19 random;

@rnd {
  $ str say
  10 = &break when
  @rnd pop str say
} for

SNOBOL4

Most Snobols lack a built-in rand( ) function. Kludgy "Linux-only" implementation: 

	input(.random,io_findunit(),1,"/dev/urandom")
while	&ALPHABET random @rand
	output = rand = rand - (rand / 20) * 20 
	eq(rand,10)	 :f(while)
end

Or using a library function: 

* rand(n) -> real x | 0 <= x < n
-include 'random.sno'

loop    ne(output = convert(rand(20)'integer'),10) :s(loop)
end

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 | r, s
  ser.start(31, 30, 0, 115200)

  s := 1337 ' PRNG seed

  repeat
    r := ||?s // 20
    ser.dec(r)
    ser.tx(32)
    if r == 10
      quit
    r := ||?s // 20
    ser.dec(r)
    ser.tx(32)

  waitcnt(_clkfreq + cnt)
  ser.stop
  cogstop(0)
Output:
8 13 1 7 19 1 15 16 9 6 5 9 1 15 5 0 6 3 9 19 8 9 10

SPL

Direct approach: 

>
  n = #.rnd(20)
  #.output(n)
  << n=10
  n = #.rnd(20)
  #.output(n)
<

With reusable code: 

>
  :1
  n = #.rnd(20)
  #.output(n)
  <-
  << n=10
  1 <->
<

SQL PL

Works with: Db2 LUW

version 9.7 or higher.

With SQL PL: 

--#SET TERMINATOR @

SET SERVEROUTPUT ON@

BEGIN
 DECLARE VAL INTEGER;
 LOOP: WHILE (TRUE = TRUE) DO
  SET VAL = INTEGER(RAND() * 20);
  CALL DBMS_OUTPUT.PUT_LINE(VAL);
  IF (VAL = 10) THEN
   LEAVE LOOP;
  END IF;
  SET VAL = INTEGER(RAND() * 20);
  CALL DBMS_OUTPUT.PUT_LINE(VAL);
 END WHILE LOOP;
END @

Output: 

db2 -td@
db2 => SET SERVEROUTPUT ON@
DB20000I  The SET SERVEROUTPUT command completed successfully.
db2 => BEGIN
...
db2 (cont.) => END @
DB20000I  The SQL command completed successfully.

4
16
9
1
10

Since V11.1, the builtin module can be used instead of RAND, like this: 

SET VAL = CALL DBMS_RANDOM.VALUE(0,20);

Stata 

while 1 {
	local n=runiformint(0,19)
	display `n'
	if `n'==10 continue, break
	display runiformint(0,19)
}

Mata

for (; 1; ) {
	printf("%f\n",n=runiformint(1,1,0,19))
	if (n==10) break
	printf("%f\n",runiformint(1,1,0,19))
}

Suneido 

forever
    {
    Print(i = Random(20))
    if i is 10
        break
    Print(i = Random(20))
    }

Swift 

while true
{
  let a = Int(arc4random()) % (20)
  print("a: \(a)",terminator: "   ")
  if (a == 10)
  {
    break
  }
  let b = Int(arc4random()) % (20)
  print("b: \(b)")
}
Output:
a: 2   b: 7
a: 16   b: 13
a: 18   b: 16
a: 10

Tcl 

while true {
    set a [expr int(20*rand())]
    puts $a
    if {$a == 10} {
        break
    }
    set b [expr int(20*rand())]
    puts $b
}

TI-89 BASIC 

Local x
Loop
  rand(20)-1 → x
  Disp x                     © new line and text
  If x = 10 Then
    Exit
  EndIf
  Output 64, 50, rand(20)-1  © paint text to the right on same line
EndLoop

TorqueScript 

for(%a = 0; %a > -1; %a++)
{
    %number = getRandom(0, 19);
    if(%number == 10)
        break;
}

Transact-SQL 

DECLARE @i INT;
WHILE 1=1
BEGIN
    SET @i = ABS(CHECKSUM(NewId())) % 20;
    PRINT @i;
    IF @i=10 BREAK;
    PRINT ABS(CHECKSUM(NewId())) % 20;
END;

TUSCRIPT 

$$ MODE TUSCRIPT
LOOP
a=RANDOM_NUMBERS (0,19,1)
IF (10==a) THEN
 PRINT "a=",a
 STOP
ELSE
 b=RANDOM_NUMBERS (0,19,1)
 PRINT "a=",a," b=",b
ENDIF
IF (10==a,b) STOP
ENDLOOP
Output:
a=0 b=17
a=11 b=13
a=3 b=16
a=17 b=13
a=8 b=11
a=8 b=0
a=6 b=2
a=10

uBasic/4tH 

Do
  n = RND(20)
  Print n
  Until n = 10
  Print RND(20)
Loop

UNIX Shell

This script gets random numbers from jot(1). If there is any error with jot(1), the script exits.

Works with: Bourne Shell
Library: jot
while true; do
	a=`jot -w %d -r 1 0 20` || exit $?
	echo $a
	test 10 -eq $a && break
	b=`jot -w %d -r 1 0 20` || exit $?
	echo $b
done

Korn Shells have a RANDOM parameter.

Works with: Bash
Works with: pdksh version 5.2.14
while true; do
  echo $((a=RANDOM%20))
  [ $a -eq 10 ] && break
  echo $((b=RANDOM%20))
done

Ursa

Translation of: Python
decl ursa.util.random r
decl int a b
while true
        set a (r.getint 19)
        out a endl console
        if (= a 10)
                break
        end while
        set b (r.getint 19)
        out b endl console
end while

VBA 

Public Sub LoopsBreak()
    Dim value As Integer
    Randomize
    Do While True
        value = Int(20 * Rnd)
        Debug.Print value
        If value = 10 Then Exit Do
        Debug.Print Int(20 * Rnd)
    Loop
End Sub

VBScript

Based on BASIC version. Demonstrates breaking out of Do/Loop and For/Next (Exit is good for getting out of functions and subs as well). 

Dim a, b, i

Do
    a = Int(Rnd * 20)
    WScript.StdOut.Write a 
    If a = 10 Then Exit Do
    b = Int(Rnd * 20)
    WScript.Echo vbNullString, b
Loop

For i = 1 To 100000
    a = Int(Rnd * 20)
    WScript.StdOut.Write a 
    If a = 10 Then Exit For
    b = Int(Rnd * 20)
    WScript.Echo vbNullString, b
Next

Visual Basic .NET

Translation of: C#
Module Program
    Sub Main()
        ' Initialize with seed 0 to get deterministic output (may vary across .NET versions, though).
        Dim rand As New Random(0)

        Do
            Dim first = rand.Next(20) ' Upper bound is exclusive.
            Console.Write(first & " ")

            If first = 10 Then Exit Do

            Dim second = rand.Next(20)
            Console.Write(second & " ")
        Loop
    End Sub
End Module
Output:
14 16 15 11 4 11 18 8 19 5 5 9 12 9 19 0 17 19 13 6 16 16 19 0 13 10 18 13 10

V (Vlang) 

import rand
import rand.seed

fn main() {
    rand.seed(seed.time_seed_array(2))
    for {
        a := rand.intn(20)?
        println(a)
        if a == 10 {
            break
        }
        b := rand.intn(20)?
        println(b)
    }
}

Wren 

import "random" for Random

var r = Random.new()
while (true) {
    var n = r.int(20)
    System.print(n)
    if (n == 10) break
    System.print(r.int(20))
}
Output:

A (mercifully short) sample run: 

1
0
13
16
2
0
10

XBasic

Works with: Windows XBasic
PROGRAM "loopbreak"

IMPORT "xst" ' for XstGetSystemTime

DECLARE FUNCTION Entry()

' Pseudo-random number generator
' Based on the rand, srand functions from Kernighan & Ritchie's book
' 'The C Programming Language'
DECLARE FUNCTION Rand()
DECLARE FUNCTION SRand(seed%%)

FUNCTION Entry()
  XstGetSystemTime (@msec)
  SRand(INT(msec) MOD 32768)
  DO
    a%% = Rand() MOD 20
    PRINT FORMAT$("##", a%%);
    IF a%% = 10 THEN EXIT DO
    b%% = Rand() MOD 20
    PRINT FORMAT$(" ##", b%%)
  LOOP
  PRINT
END FUNCTION

' Return pseudo-random integer on 0..32767
FUNCTION Rand()
  #next&& = #next&& * 1103515245 + 12345
END FUNCTION USHORT(#next&& / 65536) MOD 32768

' Set seed for Rand()
FUNCTION SRand(seed%%)
  #next&& = seed%%
END FUNCTION

END PROGRAM
Output:
17  3
 3  8
 9  7
18  5
 4  0
 9 16
 0 19
 5 18
12 16
 1  1
10

XBS 

while(true){
	set n:number = math.random(0,19);
	log(`first: {n}`);
	if(n==10){stop}
	n = math.random(0,19);
	log(`second: {n}`);
}
Output:
first: 0
second: 13
first: 11
second: 10
first: 16
second: 3
first: 8
second: 19
first: 7
second: 10
first: 10

XPL0 

include c:\cxpl\codes;
int N;
loop    [N:= Ran(20);
        IntOut(0, N);
        if N=10 then quit;
        ChOut(0, 9\tab\);
        IntOut(0, Ran(20));
        CrLf(0);
        ]
Output:
7       17
13      2
2       10
0       4
2       9
15      15
14      19
10


Yabasic 

do
	i = int(ran(19))
	print i using "##";
	print "  ";
	if i = 10 then break : fi
	i = int(ran(19))
	print i using "##", "  ";
loop
print
end

Zig 

const std = @import("std");

pub fn main() !void {
    const RndGen = std.rand.DefaultPrng;
    var rnd = RndGen.init(42);
    // possible improvement: make rng fair
    var rand_num1: u5 = undefined;
    var rand_num2: u5 = undefined;
    while (true) {
        rand_num1 = rnd.random().int(u5) % 20;
        try std.io.getStdOut().writer().print("{d}\n", .{rand_num1});
        if (rand_num1 == 10)
            break;
        rand_num2 = rnd.random().int(u5) % 20;
        try std.io.getStdOut().writer().print("{d}\n", .{rand_num2});
    }
}

zkl 

while(1){n:=(0).random(20); n.print("  "); 
   if (n==10){ println(); break; } (0).random().println();
}
Output:
7  2139341079
4  3217334923
18  2050357211
2  2061361000
10
Retrieved from "https://rosettacode.org/wiki/Loops/Break?oldid=333605"
Cookies help us deliver our services. By using our services, you agree to our use of cookies.
More information