Loops/Do-while: Difference between revisions
Applesoft BASIC |
|||
Line 525: | Line 525: | ||
loop while a mod 6 <> 0</lang> |
loop while a mod 6 <> 0</lang> |
||
==={{header|Applesoft BASIC}}=== |
|||
{{works with|Commodore BASIC}} |
|||
<lang gwbasic> 0 REMADE FOR DO WHILE |
|||
1 DEF FN MOD6(N) = N - INT (N / 6) * 6 |
|||
2 LET V4LUE = 0 |
|||
3 FOR DO = 0 TO 1 |
|||
10 LET V4LUE = V4LUE + 1 |
|||
20 PRINT V4LUE" "; |
|||
30 WHILE = FN MOD6(V4LUE) < > 0:DO = NOT WHILE: NEXT</lang> |
|||
==={{header|ASIC}}=== |
==={{header|ASIC}}=== |
||
ASIC does not have a <code>do .. while</code> construct. Equivalent using <code>WHILE</code>: |
ASIC does not have a <code>do .. while</code> construct. Equivalent using <code>WHILE</code>: |
Revision as of 23:23, 6 July 2022
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
Start with a value at 0. Loop while value mod 6 is not equal to 0. Each time through the loop, add 1 to the value then print it. The loop must execute at least once.
- Related tasks
- Loop over multiple arrays simultaneously
- Loops/Break
- Loops/Continue
- Loops/Do-while
- Loops/Downward for
- Loops/For
- Loops/For with a specified step
- Loops/Foreach
- Loops/Increment loop index within loop body
- Loops/Infinite
- Loops/N plus one half
- Loops/Nested
- Loops/While
- Loops/with multiple ranges
- Loops/Wrong ranges
- Reference
- Do while loop Wikipedia.
11l
11l doesn't have a do-while loop.
<lang 11l>V val = 0 L
val++ print(val) I val % 6 == 0 L.break</lang>
360 Assembly
- Basic
The WTO macro is in SYS1.MACLIB, which needs to be in the SYSLIB concatenation at assembly. <lang 360asm>* Do-While DOWHILE CSECT , This program's control section
BAKR 14,0 Caller's registers to linkage stack LR 12,15 load entry point address into Reg 12 USING DOWHILE,12 tell assembler we use Reg 12 as base XR 9,9 clear Reg 9 - divident value LA 6,6 load divisor value 6 in Reg 6 LA 8,WTOLEN address of WTO area in Reg 8
LOOP DS 0H
LA 9,1(,9) add 1 to divident Reg 9 ST 9,FW2 store it LM 4,5,FDOUBLE load into even/odd register pair STH 9,WTOTXT store divident in text area MVI WTOTXT,X'F0' first of two bytes zero OI WTOTXT+1,X'F0' make second byte printable WTO TEXT=(8) print it (Write To Operator macro) DR 4,6 divide Reg pair 4,5 by Reg 6 LTR 5,5 test quotient (remainder in Reg 4) BNZ RETURN if one: 6 iterations, exit loop. B LOOP if zero: loop again.
RETURN PR , return to caller. FDOUBLE DC 0FD
DC F'0'
FW2 DC F'0' WTOLEN DC H'2' fixed WTO length of two WTOTXT DC CL2' '
END DOWHILE </lang>
- Structured Macros
Although specified at the beginning (DO UNTIL), the test is done at the end of the loop (ENDDO). Structured macros (DO ENDDO) weren't in the 1963 standard of Assembler 360, but there are part of it since since 1998. <lang 360asm>* Do-While 27/06/2016 DOWHILE CSECT
USING DOWHILE,12 set base register LR 12,15 init base register SR 6,6 v=0 LA 4,1 init reg 4 DO UNTIL=(LTR,4,Z,4) do until v mod 6=0 LA 6,1(6) v=v+1 STC 6,WTOTXT v OI WTOTXT,X'F0' make editable WTO MF=(E,WTOMSG) display v LR 4,6 v SRDA 4,32 shift dividend to reg 5 D 4,=F'6' v/6 so r4=remain & r5=quotient ENDDO , end do BR 14 return to caller
WTOMSG DS 0F full word alignment for wto WTOLEN DC AL2(L'WTOTXT+4) length of WTO buffer
DC H'0' must be zero
WTOTXT DS C one char
END DOWHILE</lang>
6502 Assembly
Code is called as a subroutine (i.e. JSR DoWhileSub). Specific OS/hardware routines for printing are left unimplemented. <lang 6502asm>DoWhileSub: PHA TYA PHA ;push accumulator and Y register onto stack
LDY #0 DoWhileLoop: INY JSR DisplayValue ;routine not implemented TYA SEC Modulus: SBC #6 BCS Modulus ADC #6 BNE DoWhileLoop
PLA TAY PLA ;restore Y register and accumulator from stack RTS ;return from subroutine</lang>
AArch64 Assembly
<lang AArch64 Assembly> /* ARM assembly AARCH64 Raspberry PI 3B */ /* program loopdowhile64.s */
/*******************************************/ /* Constantes file */ /*******************************************/ /* for this file see task include a file in language AArch64 assembly*/ .include "../includeConstantesARM64.inc"
/*********************************/ /* Initialized data */ /*********************************/ .data szMessResult: .asciz "Counter = @ \n" // message result
/*********************************/ /* UnInitialized data */ /*********************************/ .bss sZoneConv: .skip 24 /*********************************/ /* code section */ /*********************************/ .text .global main main: // entry of program
mov x20,0 // indice mov x21,6
1: // begin loop
mov x0,x20 ldr x1,qAdrsZoneConv // conversion value value bl conversion10 // decimal ldr x0,qAdrszMessResult ldr x1,qAdrsZoneConv // display conversion bl strInsertAtCharInc // insert result at @ character bl affichageMess // display message add x20,x20,1 // increment counter udiv x0,x20,x21 // divide by 6 msub x1,x0,x21,x20 // compute remainder cbnz x1,1b // loop if remainder <> zéro
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 /********************************************************/ /* File Include fonctions */ /********************************************************/ /* for this file see task include a file in language AArch64 assembly */ .include "../includeARM64.inc"
</lang>
Action!
<lang Action!>Proc Main()
byte A
A=0 Do A==+1 PrintBE(A) Until A Mod 6=0 Od
Return</lang>
ActionScript
<lang actionscript>var val:int = 0; do {
trace(++val);
} while (val % 6);</lang>
Ada
<lang ada>loop
Value := Value + 1; Put (Value); exit when Value mod 6 = 0;
end loop;</lang> Here is an alternative version: <lang ada>for Value in 0..Integer'Last loop
Put (Value); exit when Value mod 6 = 0;
end loop;</lang>
Agena
Tested with Agena 2.9.5 Win32 <lang agena>scope
local i := 0; do inc i, 1; print( i ) as ( i % 6 ) <> 0
epocs</lang>
Aime
<lang aime>integer a;
a = 0; do {
a += 1; o_integer(a); o_byte('\n');
} while (a % 6 != 0);</lang>
ALGOL 60
No structured control instructions in Algol 60 to perform this task. Use of 2 harmful GOTOs. I agree Edsger Dijkstra communication "Go To Statement Considered Harmful", ACM 1968. <lang algol60>'BEGIN' 'COMMENT' Loops DoWhile - Algol60 - 22/06/2018;
'INTEGER' I; I:=0;
LOOP:
I:=I+1; OUTINTEGER(1,I); 'IF' I=I'/'6*6 'THEN' 'GOTO' ENDLOOP; 'GOTO' LOOP;
ENDLOOP: 'END'</lang>
- Output:
+1 +2 +3 +4 +5 +6
An alternate ("Goto-less") approach
While "goto" may (oddly enough) actually be clearer in this particular context, it is possible to avoid it by using the for-while statement and a boolean flag to implement a test-at-the-bottom loop. (Note that though the A60 interpreter permits, it thankfully does not require, the ugly tick marks around reserved words which mar many (but not the Burroughs) ALGOL 60 translators.) <lang algol60> begin
integer i; boolean another; i := 0; another := true; for i := i + 1 while another do
begin outinteger(1,i); comment - repeat until i mod 6 = 0; if i = (i div 6) * 6 then another := false; end;
end </lang>
- Output:
1 2 3 4 5 6
ALGOL 68
<lang algol68>FOR value WHILE
print(value);
- WHILE # value MOD 6 /= 0 DO
SKIP
OD</lang>
ALGOL W
<lang algolw>begin
integer i; i := 0; while begin i := i + 1; write( i ); ( i rem 6 ) not = 0 end do begin end
end.</lang>
AmigaE
<lang amigae>PROC main()
DEF i = 0 REPEAT i := i + 1 WriteF('\d\n', i) UNTIL Mod(i, 6) = 0
ENDPROC</lang>
ARM Assembly
<lang ARM Assembly>
/* ARM assembly Raspberry PI */ /* program loopdowhile.s */
/* Constantes */ .equ STDOUT, 1 @ Linux output console .equ EXIT, 1 @ Linux syscall .equ WRITE, 4 @ Linux syscall
/*********************************/ /* Initialized data */ /*********************************/ .data szMessResult: .ascii "Counter = " @ message result sMessValeur: .fill 12, 1, ' '
.asciz "\n"
/*********************************/ /* UnInitialized data */ /*********************************/ .bss /*********************************/ /* code section */ /*********************************/ .text .global main main: @ entry of program
push {fp,lr} @ saves 2 registers mov r4,#0
1: @ begin loop
mov r0,r4
ldr r1,iAdrsMessValeur @ display value bl conversion10 @ call function with 2 parameter (r0,r1) ldr r0,iAdrszMessResult bl affichageMess @ display message add r4,#1 @ increment counter mov r0,r4 mov r1,#6 @ division conuter by 6 bl division cmp r3,#0 @ remainder = zéro ? bne 1b @ no ->begin loop one
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 /******************************************************************/ /* 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 */
/***************************************************/ /* 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
</lang>
AppleScript
<lang AppleScript> on printConsole(x) return x as string end printConsole
set {i, table} to {0, {return}} repeat while (i mod 6 is not 0 or i is not 6) set i to i + 1 set end of table to i & return printConsole(table) end repeat </lang>
- Output:
" 1 2 3 4 5 6 "
Arturo
<lang rebol>value: 0 until [ value: value + 1 print value ] [ 0 = value%6 ]</lang>
- Output:
1 2 3 4 5 6
Asymptote
Asymptote's control structures are similar to those in C, C++, or Java <lang Asymptote>int i = 0; do {
++i; write(" ", i, suffix=none);
} while (i % 6 != 0);</lang>
AutoHotkey
<lang AutoHotkey>While mod(A_Index, 6) ;comment:everything but 0 is considered true
output = %output%`n%A_Index%
MsgBox % output</lang>
AWK
<lang awk>BEGIN {
val = 0 do { val++ print val } while( val % 6 != 0)
}</lang>
Axe
While Axe does not have explicit do-while loops, they can be easily emulated using an infinite loop with a conditional terminator: <lang axe>0→A While 1
A++ Disp A▶Dec,i
End!If A^6</lang>
BASIC
<lang qbasic>a = 0 do
a = a + 1 print a
loop while a mod 6 <> 0</lang>
Applesoft BASIC
<lang gwbasic> 0 REMADE FOR DO WHILE
1 DEF FN MOD6(N) = N - INT (N / 6) * 6 2 LET V4LUE = 0 3 FOR DO = 0 TO 1 10 LET V4LUE = V4LUE + 1 20 PRINT V4LUE" "; 30 WHILE = FN MOD6(V4LUE) < > 0:DO = NOT WHILE: NEXT</lang>
ASIC
ASIC does not have a do .. while
construct. Equivalent using WHILE
:
<lang basic>
REM Loops/Do-while
I = 0 REM first iteration - before the While I = I + 1 PRINT I IMod6 = I MOD 6 WHILE IMod6 <> 0
I = I + 1 PRINT I IMod6 = I MOD 6
WEND
END </lang>
- Output:
1 2 3 4 5 6
Equivalent using conditional jump: <lang basic> REM Loops/Do-while
I = 0 LoopStart:
I = I + 1 PRINT I IMod6 = I MOD 6 IF IMod6 <> 0 THEN LoopStart:
END </lang>
- Output:
As above
BaCon
<lang freebasic> a=0 REPEAT
INCR a PRINT a
UNTIL MOD(a,6) == 0 </lang>
BASIC256
<lang BASIC256>i = 0
do i += 1 print i; " "; until i mod 6 = 0 print end</lang>
BBC BASIC
<lang bbcbasic>a = 0 REPEAT
a = a + 1 PRINT a
UNTIL a MOD 6 = 0</lang>
Commodore BASIC
<lang basic>50 rem does not have do-while simultate using for-next 100 x=0 120 for b=-1 to 0 step 0 130 x=x+1 140 print x 150 b=x/6<>int(x/6) 160 next x </lang>
IS-BASIC
<lang IS-BASIC>100 LET I=0 110 DO 120 LET I=I+1 130 PRINT I 140 LOOP UNTIL MOD(I,6)=0</lang>
Minimal BASIC
Minimal BASIC does not have a do .. while
construct. Equivalent using conditional jump:
<lang gwbasic>
10 REM Loops/Do-while
20 LET I=0
30 LET I=I+1
40 PRINT I
50 IF INT(I/6)*6 <> I THEN 30
60 END
</lang>
QBasic
<lang qbasic>a = 0 DO
a = a + 1 PRINT a;
LOOP WHILE a MOD 6 <> 0</lang>
Run BASIC
Run Basic does not have a do .. while
construct. Equivalent using conditional jump:
<lang lb>i = 0
[start]
i = i +1
print i; " ";
if i mod 6 <> 0 then [start]</lang>
Sinclair ZX81 BASIC
<lang basic>10 LET X=0 20 LET X=X+1 30 PRINT X 40 IF X/6<>INT (X/6) THEN GOTO 20</lang>
True BASIC
<lang basic>LET i = 0
DO
LET i = i + 1 PRINT i; " ";
LOOP WHILE REMAINDER(i, 6) <> 0 PRINT END</lang>
XBasic
<lang xbasic> PROGRAM "dowhile"
DECLARE FUNCTION Entry()
FUNCTION Entry()
val% = 0 DO INC val% PRINT val% LOOP WHILE val% MOD 6 <> 0 ' or LOOP UNTIL val% MOD 6 = 0
END FUNCTION END PROGRAM </lang>
Tiny BASIC
<lang Tiny BASIC> REM TinyBasic does not have a do .. while construct. Equivalent using conditional jump:
LET i = 0
10 LET i = i + 1
PRINT i IF (i / 6) * 6 <> i THEN GOTO 10 END</lang>
Yabasic
<lang yabasic>i = 0
repeat i = i + 1 print i, " "; until mod(i, 6) = 0 print</lang>
bc
<lang bc>i = 0 for (;;) { ++i /* increments then prints i */ if (i % 6 == 0) break } quit</lang>
Befunge
<lang befunge>0>1+:.v
|%6: < @</lang>
C
<lang c>int val = 0; do{
val++; printf("%d\n",val);
}while(val % 6 != 0);</lang>
C#
<lang csharp>int a = 0;
do {
a += 1; Console.WriteLine(a);
} while (a % 6 != 0);</lang>
C++
<lang cpp>int val = 0; do{
val++; std::cout << val << std::endl;
}while(val % 6 != 0);</lang>
Chapel
<lang chapel>var val = 0; do {
val += 1; writeln(val);
} while val % 6 > 0;</lang>
ChucK
<lang> 0 => int value; do {
value++; <<<value>>>;
} while(value % 6 != 0); </lang>
Clipper
<lang clipper> Local n := 0
DO WHILE .T. ? ++n IF n % 6 == 0 EXIT ENDIF ENDDO</lang>
Clojure
<lang Clojure>(loop [i 0]
(let [i* (inc i)] (println i*) (when-not (zero? (mod i* 6)) (recur i*))))</lang>
COBOL
The COBOL equivalent of a do-while loop is PERFORM WITH TEST AFTER UNTIL some-condition
.
<lang cobol> IDENTIFICATION DIVISION.
PROGRAM-ID. loop-do-while.
DATA DIVISION. WORKING-STORAGE SECTION. 01 i PIC 99 VALUE 0.
PROCEDURE DIVISION. PERFORM WITH TEST AFTER UNTIL FUNCTION MOD(i, 6) = 0 ADD 1 TO i DISPLAY i END-PERFORM
GOBACK .</lang>
Coco
Do-while loops are a JavaScript feature removed in CoffeeScript but re-added in Coco.
<lang coco>v = 0 do
console.log ++v
while v % 6</lang>
CoffeeScript
CoffeeScript doesn't have do {} while ()
loop, but it can be emulated using loop
statement and break unless
statement.
<lang coffeescript>val = 0
loop
console.log ++val break unless val % 6</lang>
ColdFusion
<lang cfm><cfscript>
value = 0; do { value += 1; writeOutput( value ); } while( value % 6 != 0 );
</cfscript></lang>
Common Lisp
<lang lisp>(let ((val 0))
(loop do (incf val) (print val) while (/= 0 (mod val 6))))</lang>
loop can set up temporary values, and incf returns a value, so it's also possible to do
<lang lisp>(loop with val = 0
do (print (incf val)) until (= 0 (mod val 6)))</lang>
Using DO
<lang lisp> (do* ((a 0) ; Initialize to 0
(b (incf a) (incf b))) ; Set first increment and increment on every loop ((zerop (mod b 6)) (print b)) ; Break condition and print last value `6' (right?) (print b)) ; On every loop print value
</lang>
- Output:
1 2 3 4 5 6
D
<lang d>import std.stdio;
void main() {
int val; do { val++; write(val, " "); } while (val % 6 != 0);
}</lang>
- Output:
1 2 3 4 5 6
dc
<lang dc>0 si [i = 0]sz [2Q]sA [A = code to break loop]sz [
li 1 + p [print it = i + 1]sz d si [i = it, leave it on stack]sz 6 % 0 =A [call A if 0 == it % 6]sz 0 0 =B [continue loop]sz
]sB 0 0 =B</lang>
Delphi
<lang Delphi>program Loop;
{$APPTYPE CONSOLE}
var
I: Integer;
begin
I:= 0; repeat Inc(I); Write(I:2); until I mod 6 = 0; Writeln; Readln;
end.</lang>
Draco
<lang draco>proc nonrec main() void:
byte i; i := 0; while i := i + 1; write(i:2); i % 6 ~= 0 do od
corp</lang>
- Output:
1 2 3 4 5 6
Dragon
<lang dragon>val = 0 do{
val++ showln val
}while(val % 6 != 0)</lang>
DUP
DUP only provides a while loop in the form of [condition][block]#
, where the block is executed in a loop as long as the condition is nonzero/true.
A do-while loop is technically nothing more than executing the block once before running an ordinary while loop, so we simply define an operator or function that contains the block (comments in curly braces):
<lang DUP>[1+$.' ,]⇒A {operator definition: PUSH 1, ADD, DUP, print top of stack to SDTOUT, print whitespace} [1+$.' ,]a: {function definition}</lang>
and put the defined block in front of the while loop, and inside the while loop itself:
If the block was defined as an operator, the whole program would look like this (comments in curly braces):
<lang DUP>[1+$.' ,]⇒A 0 A[$6/%][A]# {PUSH 0, execute operator A, [DUP, PUSH 6, MOD/DIV, POP][execute operator A]#}</lang>
And if the block is defined as a named function:
<lang DUP>[1+$.' ,]a: 0 a;![$6/%][a;!]#</lang>
Result:
<lang DUP>1 2 3 4 5 6</lang>
DWScript
<lang Delphi> var i := 0;
repeat
Inc(i); PrintLn(i);
until i mod 6 = 0; </lang> Bold text
Dyalect
<lang dyalect>var x = 0
do {
x += 1 print(x)
} while x % 6 != 0</lang>
E
E does not have an official do-while construct, but the primitive which loops are built out of (which calls a function which returns a boolean indicating whether it should be called again) can be used to construct a do-while. <lang e>var x := 0 __loop(fn {
x += 1 println(x) x % 6 != 0 # this is the return value of the function
})</lang>
Ela
<lang ela>open monad io
loop n | n % 6 == 0 = do return ()
| else = do putStrLn (show n) loop (n+1)
_ = loop 10 ::: IO</lang>
Elixir
<lang elixir>defmodule Loops do
def do_while(n) do n1 = n + 1 IO.puts n1 if rem(n1, 6) == 0, do: :ok, else: do_while(n1) end
end
Loops.do_while(0)</lang>
Emacs Lisp
The condition form for while
can be a progn
to evaluate arbitrary code before the loop condition. The body of a while
can be empty.
<lang Lisp>(let ((val 0))
(while (progn (setq val (1+ val)) (message "%d" val) (/= 0 (mod val 6)))))</lang>
Alternatively, the loop can be rewritten to check for the exit condition and fulfill it at the end of the loop body.
<lang Lisp>(let ((val 0) done)
(while (not done) (setq val (1+ val)) (message "%d" val) (setq done (zerop (mod val 6)))))</lang>
Erlang
<lang Erlang> do() -> do(0).
do(0) -> io:fwrite( "0 " ),
do( 1 );
do(N) when N rem 6 =:= 0 -> io:format("~w~n", [N]); do(N) -> io:fwrite( "~p ", [N] ), do(N+1). </lang>
ERRE
<lang ERRE> A=0 REPEAT
A=A+1 PRINT(A)
UNTIL A MOD 6=0 !UNTIL A-6*INT(A/6)=0 for C-64 </lang>
Euphoria
<lang euphoria> include std/console.e include std/math.e
atom x = 0
loop do x += 1 ?x until(mod(x,6)) = 0 end loop
if getc(0) then end if </lang>
F#
If you must have a loop then this is acceptable F# <lang fsharp> let rec loop n =
printfn "%d " n if (n+1)%6 > 0 then loop (n+1)
loop 0 </lang>
But I prefer this way: <lang fsharp> Seq.initInfinite id |> Seq.takeWhile(fun n->n=0 || n%6>0) |> Seq.iter (fun n-> printfn "%d" n) </lang>
Either produces:
- Output:
0 1 2 3 4 5
Many of the solutions to this task show no output in spite of it being required in the task dexcription, so who knows what they do? Of some that have output they think it should be 1 to 6, who can tell from the task description? The following produces 1..6.
<lang fsharp> // Loops/Do-while. Nigel Galloway: February 14th., 2022 Seq.unfold(fun n->match n with Some n->let n=n+1 in Some(n,if n%6=0 then None else Some(n)) |_->None)(Some 0)|>Seq.iter(printfn "%d") </lang>
- Output:
1 2 3 4 5 6
Factor
<lang factor>0 [ dup 6 mod 0 = not ] [ [ . ] [ 1 + ] bi ] do while drop</lang>
Fantom
There is no do-while statement in Fantom, so instead use an infinite while loop with a break statement:
<lang fantom> class Main {
public static Void main () { i := 0 while (true) { i += 1 echo (i) if (i % 6 == 0) break // end loop on condition } }
} </lang>
Forth
<lang forth>: do-until
0 begin 1+ dup . dup 6 mod 0= until drop ;</lang>
Fortran
<lang fortran>INTEGER :: i = 0 DO
i = i + 1 WRITE(*, *) i IF (MOD(i, 6) == 0) EXIT
END DO</lang>
<lang fortran> PROGRAM DOWHILE C Initialize modulus and value.
INTEGER MODLUS, IVALUE PARAMETER (MODLUS = 6) IVALUE = 0
C FORTRAN 77 has no do-while structure -- not semantically. It is not C difficult to simulate it using GOTO, however:
10 CONTINUE IVALUE = IVALUE + 1 WRITE (*,*) IVALUE IF (.NOT. (MOD(IVALUE, MODLUS) .EQ. 0)) GOTO 10
STOP END</lang>
<lang fortran> IVALUE = 0
10 CONTINUE IVALUE=IVALUE+1 WRITE(6,301) IVALUE 301 FORMAT(I5) IF(MOD(IVALUE,6).NE.0) GOTO 10 END</lang>
<lang fortran> IVALUE = 0
10 IVALUE=IVALUE+1 WRITE 301,IVALUE 301 FORMAT(I5) IF(IVALUE-IVALUE/6*6) 10,20,10 20 STOP END</lang>
Fortress
Due to the way that Fortress works, you have to use a label to escape a loop upon a specified condition being met. There is no traditional break
equivalent.
<lang fortress> component loops_do_while
export Executable
var x:ZZ32 = 0 run() = label loop while true do x += 1 println(x)
if (x MOD 6) = 0 then exit loop end end end loop
end </lang>
- Output:
1 2 3 4 5 6
FreeBASIC
<lang freebasic>' FB 1.05. 0 Win64
Dim i As Integer = 0 Do
i += 1 Print i; " ";
Loop While i Mod 6 <> 0 Print Sleep</lang>
- Output:
1 2 3 4 5 6
Frink
<lang frink>n = 0 do {
n = n + 1 println[n]
} while n mod 6 != 0</lang>
FutureBasic
<lang futurebasic>window 1
dim as long i
do
i++ print i
until ( i mod 6 == 0 )
HandleEvents</lang> Output:
1 2 3 4 5 6
Gambas
Click this link to run this code <lang gambas>Public Sub Main() Dim siCount As Short
Repeat
Inc siCount Print siCount;;
Until siCount Mod 6 = 0
End</lang> Output:
1 2 3 4 5 6
GAP
<lang gap>n := 0; repeat
n := n + 1; Print(n, "\n");
until RemInt(n, 6) = 0;</lang>
GML
<lang GML>i = 0 do
{ i += 1 show_message(string(i)) }
until (i mod 6 = 0)</lang>
Go
There is no explicit do-while in Go, but it can be simulated with a range-based for loop and the break statement. <lang go>package main
import "fmt"
func main() { var value int for { value++ fmt.Println(value)
if value%6 != 0 { break }
} }</lang>
- Output:
1 2 3 4 5 6
It can also be simulated without using a break statement as follows: <lang go>package main
import "fmt"
func main() { var value int for ok := true; ok; ok = value%6 != 0 { value++ fmt.Println(value) } }</lang>
- Output:
Same as before.
- <lang go>package main
import "fmt"
func main() { // do-while loop 1 n1 := 2 for n1 < 6 { n1 *= 2 } fmt.Println(n1) // prt 8 // do-while loop 2 n2 := 2 for ok := true; ok; ok = n2%8 != 0 { n2 *= 2 } fmt.Println(n2) // prt 8 // do-while loop 3 n3 := 2 for { n3 *= 2 if n3 >= 6 { break } } fmt.Println(n3) // prt 8 }</lang>
Groovy
For Groovy 3.0.0 and later. <lang groovy>def i = 0 do {
i++ println i
} while (i % 6 != 0)</lang> Previous versions of Groovy did not have a bottom-checking loop construct. Workaround is to use an "infinite" while loop with a conditional break as the last statement. <lang groovy>def i = 0 while (true) {
i++ println i if (i % 6 == 0) break
}</lang>
- Output:
1 2 3 4 5 6
GW-BASIC
GW-BASIC does not have a do .. while
construct.
Equivalent using WHILE
:
<lang gwbasic>
10 LET I% = 0
20 ' first iteration - before the WHILE
30 LET I% = I% + 1
40 PRINT I%
50 WHILE I% MOD 6 <> 0
60 LET I% = I% + 1
70 PRINT I%
80 WEND
</lang>
Equivalent using GOTO
:
<lang gwbasic> 10 LET I% = 0 20 LET I% = I% + 1 30 PRINT I% 40 IF I% MOD 6 <> 0 THEN GOTO 20 </lang>
Harbour
<lang visualfoxpro>LOCAL n := 0
DO WHILE .T.
? ++n IF n % 6 == 0 EXIT ENDIF
ENDDO</lang>
Haskell
<lang haskell>import Data.List import Control.Monad import Control.Arrow
doWhile p f n = (n:) $ takeWhile p $ unfoldr (Just.(id &&& f)) $ succ n</lang> Example executed in GHCi: <lang haskell>*Main> mapM_ print $ doWhile ((/=0).(`mod`6)) succ 0 0 1 2 3 4 5</lang>
The standard Prelude also includes, without further import or definition, an until function, which takes three arguments – a predicate function, a transformation function, and an initial value.
<lang haskell>main :: IO () main =
mapM_ print . reverse $ until (\(x:_) -> (x > 0) && (mod x 6 == 0)) (\xs@(x:_) -> succ x : xs) [0]</lang>
- Output:
0 1 2 3 4 5 6
With mutable references
Using iterateWhile from monad-loops package <lang haskell>import Data.IORef import Control.Monad.Loops
main = do
x <- newIORef 0; iterateWhile (\val -> val `mod` 6 /= 0 ) $ do modifyIORef x (+1) val <- readIORef x print val return val</lang>
Haxe
<lang haxe>var val = 0;
do {
val++; Sys.println(val);
} while( val % 6 != 0);</lang>
HolyC
<lang holyc>U8 i = 0; do {
i++; Print("%d\n", i);
} while (i % 6 != 0);</lang>
Icon and Unicon
Icon and Unicon do not have a do-while looping control with end of loop checking. There are four looping controls 'every', 'repeat', 'until', and 'while' (see Introduction to Icon and Unicon/Looping Controls for more information.) <lang Icon>procedure main()
i := 0 repeat {
write(i +:= 1) if i % 6 = 0 then break }
end</lang>
J
J is array-oriented, so there is very little need for loops. For example, one could satisfy this task this way:
,. ([^:(0=6|])>:)^:a: 0
J does support loops for those times they can't be avoided (just like many languages support gotos for those time they can't be avoided). <lang j>3 : 0 ] 0
NB. The 'st' in 'whilst' stands for 'skip test'
whilst. 0 ~: 6 | y do. y 1!:2 ]2 y =. y+1 end.
i.0 0 )</lang>
Though it's rare to see J code like this.
Java
<lang java>int val = 0; do{
val++; System.out.println(val);
}while(val % 6 != 0);</lang>
JavaScript
Javascript: Imperative
<lang javascript>var val = 0; do {
print(++val);
} while (val % 6);</lang>
Javascript: Functional
ES5
In a functional idiom of JavaScript we cannot use a Do While statement, as it returns no value and is not a composable expression. We can, however achieve the same effect with a composable doWhile function, which takes three arguments, and returns the output series as a value.
- An initial value,
- a Do function which transforms that value repetitively, corresponding to the body of the loop,
- and a conditional While function.
<lang JavaScript>function doWhile(varValue, fnBody, fnTest) {
'use strict'; var d = fnBody(varValue); // a transformed value
return fnTest(d) ? [d].concat( doWhile(d, fnBody, fnTest) ) : [d];
}
console.log(
doWhile(0, // initial value function (x) { // Do body, returning transformed value return x + 1; }, function (x) { // While condition return x % 6; } ).join('\n')
);</lang>
Output: <lang JavaScript>1 2 3 4 5 6</lang>
Alternatively, if we assume instead that the unstated problem was not to produce repetitive computation, but to derive the membership of a set we could interpret the task as a request for a JavaScript implementation of the takeWhile function – a familiar staple of functional list processing.
So, for example, something like:
<lang JavaScript>function range(m, n) {
'use strict'; return Array.apply(null, Array(n - m + 1)).map( function (x, i) { return m + i; } );
}
function takeWhile(lst, fnTest) {
'use strict'; var varHead = lst.length ? lst[0] : null; return varHead ? ( fnTest(varHead) ? [varHead].concat( takeWhile(lst.slice(1), fnTest) ) : [] ) : []
}
console.log(
takeWhile( range(1, 100), function (x) { return x % 6; } ).join('\n')
);</lang>
Output: <lang JavaScript>1 2 3 4 5</lang>
ES6
A process or value of this kind might be better expressed (in functionally composed JavaScript) with an unfold or until function, returning a list.
<lang JavaScript>(() => {
'use strict';
// unfoldr :: (b -> Maybe (a, b)) -> b -> [a] function unfoldr(mf, v) { for (var lst = [], a = v, m; (m = mf(a)) && m.valid;) { lst.push(m.value), a = m.new; } return lst; }
// until :: (a -> Bool) -> (a -> a) -> a -> a function until(p, f, x) { let v = x; while(!p(v)) v = f(v); return v; }
let result1 = unfoldr( x => { return { value: x, valid: (x % 6) !== 0, new: x + 1 } }, 1 );
let result2 = until( m => (m.n % 6) === 0, m => { return { n : m.n + 1, xs : m.xs.concat(m.n) }; }, { n: 1, xs: [] } ).xs; return [result1, result2];
})(); </lang>
<lang JavaScript>[[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]</lang>
ES6 is a superset of Javascript so the Javascript and ES5 solution is valid. An example of a do-while loop in a generator follows that produces correct output:
<lang JavaScript> // generator with the do while loop function* getValue(stop) {
var i = 0; do { yield ++i; } while (i % stop != 0);
}
// function to print the value and invoke next function printVal(g, v) {
if (!v.done) { console.log(v.value); setImmediate(printVal, g, g.next()); }
}
(() => {
var gen = getValue(6); printVal(gen, gen.next());
})(); </lang>
<lang JavaScript> 1 2 3 4 5 6 </lang>
jq
In jq 1.4, the "recurse" built-in always emits the input value, and so to accomplish the task specified here, we shall define a control structure: "do_while(action; condition)" as follows: <lang jq># Perform the action, then check the condition, etc def do_while( action; condition ):
def w: action | if (condition | not) then empty else ., w end; w;</lang>
The task: <lang jq>0 | do_while( .+1; . % 6 != 0 )</lang>
- Output:
1 2 3 4 5
Julia
Julia has no do-while construct. Here is one of several ways to implement do-while behavior.
<lang Julia> julia> i = 0 0
julia> while true
println(i) i += 1 i % 6 == 0 && break end
0 1 2 3 4 5 </lang>
Using a macro that mimics the classic C style do-while.
Notice that the symbol while
cannot be used as it is a keyword, which is why when
is used instead, also the macro definition is wrapped in a @eval
macro invocation since do
is also a keyword, but in Julia macro calls are prefixed by @
so this is only an issue during the macro definition, not when invoked, ie. @do block when condition
).
<lang Julia> julia> @eval macro $(:do)(block, when::Symbol, condition)
when ≠ :when && error("@do expected `when` got `$s`") quote let $block while $condition $block end end end |> esc end
@do (macro with 1 method)
julia> i = 0 0
julia> @do begin
@show i i += 1 end when i % 6 ≠ 0
i = 0 i = 1 i = 2 i = 3 i = 4 i = 5 </lang>
Here is mostly the same macro, but with the conditional clause used first, which is arguably more readable.
<lang Julia> julia> macro do_while(condition, block)
quote let $block while $condition $block end end end |> esc end
@do_while (macro with 1 method)
julia> i = 0 0
julia> @do_while i % 6 ≠ 0 begin
@show i i += 1 end
i = 0 i = 1 i = 2 i = 3 i = 4 i = 5 </lang>
Kotlin
<lang scala>// version 1.0.6
fun main(args: Array<String>) {
var value = 0 do { println(++value) } while (value % 6 != 0)
}</lang>
- Output:
1 2 3 4 5 6
LabVIEW
This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.
Lasso
<lang Lasso>local(x = 0) while(#x % 6 > 0 || #x == 0) => {^ ++#x '\r' // for formatting ^}</lang>
Lambdatalk
<lang scheme> {def do_while
{def do_while.r {lambda {:i} {if {= {% :i 6} 0} then :i (end of loop) else :i {do_while.r {+ :i 1}}}}} {lambda {:i} :i {do_while.r {+ :i 1}}}}
-> do_while
{do_while 0} -> 0 1 2 3 4 5 6 (end of loop) </lang>
Liberty BASIC
<lang lb> a = 0 do
a =a +1 print a
loop until ( a mod 6) = 0 </lang>
See also BASIC
Lingo
Lingo has no do..while, but here how this behavior can be implemented: <lang lingo>i = 0 repeat while TRUE
i = i+1 put i if i mod 6 = 0 then exit repeat
end</lang>
Lisaac
<lang Lisaac>+ val : INTEGER; {
val := val + 1; val.print; '\n'.print; val % 6 != 0
}.while_do { };</lang>
LiveCode
<lang LiveCode>repeat while n mod 6 is not 0 or n is 0
add 1 to n put n
end repeat</lang>
Logo
<lang logo>make "val 0 do.while [make "val :val + 1 print :val] [notequal? 0 modulo :val 6] do.until [make "val :val + 1 print :val] [equal? 0 modulo :val 6]
to my.loop :n
make "n :n + 1 print :n if notequal? 0 modulo :n 6 [my.loop :n]
end my.loop 0</lang>
Lua
Lua doesn't have a do .. while
construct.
<lang lua> i=0 repeat
i=i+1 print(i)
until i%6 == 0 </lang>
M2000 Interpreter
<lang M2000 Interpreter> Module checkit {
x=0 \\ Do or Repeat Do { x++ Print x } Until x mod 6=0 x=0 { \\ when enter to block the loop flag change to false x++ if x mod 6<>0 Then loop ' set loop flag of current block to true \\ when block end check Loop flag and if true execute block again Print X }
} Checkit </lang>
- Output:
1 2 3 4 5 6 1 2 3 4 5 6
Maple
<lang Maple>val := 0: do
val := 1 + val; print( val ); if irem( val, 6 ) = 0 then break end if;
end do:</lang>
Mathematica /Wolfram Language
Because everything is an expression in Mathematica, While[body;condition]
tests condition
after body
has been executed at least once.
<lang Mathematica>value = 0;
While[
value++; Print[value]; Mod[value,6]!=0
]</lang>
MATLAB / Octave
<lang Matlab> a=0;
while (1) a = a+1; disp(a); if (~mod(a,6)) break; end; end; </lang>
Maxima
<lang maxima>block([n: 0], do (ldisp(n: n + 1), if mod(n, 6) = 0 then return('done)))$</lang>
MAXScript
<lang maxscript>a = 0 do (
print a a += 1
) while mod a 6 != 0</lang>
Metafont
Metafont has no a do-while construct; the same thing can be done using a forever loop and exitif.
<lang metafont>a := 0; forever: show a; a := a + 1; exitif a mod 6 = 0; endfor end</lang>
Microsoft Small Basic
Microsoft Small Basic does not have a do .. while
construct.
Equivalent using While
:
<lang microsoftsmallbasic>
i = 0
' first iteration - before the While
i = i + 1
TextWindow.WriteLine(i)
While Math.Remainder(i, 6) <> 0
i = i + 1 TextWindow.WriteLine(i)
EndWhile
</lang>
Equivalent using Goto
:
<lang microsoftsmallbasic>
i = 0
loopStart:
i = i + 1
TextWindow.WriteLine(i)
If Math.Remainder(i, 6) <> 0 Then
Goto loopStart
EndIf </lang>
min
<lang min>0 (dup 6 mod 0 == over 0 != and) 'pop (puts succ) () linrec</lang>
MIPS Assembly
<lang mips> .text main: li $s0, 0 # start at 0. li $s1, 6 loop: addi $s0, $s0, 1 # add 1 to $s0 div $s0, $s1 # divide $s0 by $s1. Result is in the multiplication/division registers mfhi $s3 # copy the remainder from the higher multiplication register to $s3 move $a0, $s0 # variable must be in $a0 to print li $v0, 1 # 1 must be in $v0 to tell the assembler to print an integer syscall # print the integer in $a0 bnez $s3, loop # if $s3 is not 0, jump to loop
li $v0, 10 syscall # syscall to end the program </lang>
МК-61/52
<lang>0 П4 КИП4 ИП4 6 / {x} x=0 02 С/П</lang>
Modula-2
<lang modula2>MODULE DoWhile;
IMPORT InOut;
VAR i: INTEGER;
BEGIN
i := 0; REPEAT INC(i); InOut.WriteInt(i, 1); InOut.WriteLn; UNTIL i MOD 6 = 0;
END DoWhile.</lang>
Modula-3
This is very similar to the Modula-2 code above. <lang modula3>REPEAT
i := i + 1; IO.Put(Fmt.Int(i));
UNTIL i MOD 6 = 0;</lang>
Monicelli
The do-while loop is the only kind of loop available in Monicelli <lang monicelli> stuzzica
... # loop body
e brematura anche, se <expr> # exit if <expr> is false </lang>
MUMPS
<lang MUMPS>DOWHILELOOP
set val = 0 do { set val = val + 1 write val,! } while ((val # 6) '= 0) quit</lang>
- Output:
SAMPLES>do ^DOWHILELOOP 1 2 3 4 5 6
Neko
<lang ActionScript>/**
Loops/Do-while in Neko Tectonics: nekoc loops-do-while.neko neko loops-do-while
- /
var index = 0; do {
index += 1; $print(index, "\n");
} while (index % 6) != 0</lang>
- Output:
prompt$ nekoc loops-do-while.neko prompt$ neko loops-do-while 1 2 3 4 5 6
Nemerle
<lang Nemerle>mutable x = 0; do {
x++; WriteLine($"$x");
} while (x % 6 != 0)</lang>
NetRexx
In NetRexx the do–while construct is implemented via the until expru
conditional clause of the loop
instruction. The expression expru in the until expru
clause is evaluated at the end of the loop, guaranteeing that the loop will be executed at least once.
<lang NetRexx>/* NetRexx */
options replace format comments java crossref savelog symbols nobinary
say say 'Loops/Do-while'
i_ = 0 loop until i_ // 6 = 0 i_ = i_ + 1 say i_ end
</lang>
NewLISP
<lang NewLISP>(let ((i 0))
(do-until (= 0 (% i 6))
(println (++ i))))</lang>
Nim
Nim does not have a do-while loop. The standard way to simulate it consists in an infinite loop with a break statement:
<lang Nim>var val = 0 while true:
inc val echo val if val mod 6 == 0: break</lang>
It's also easy to write your own doWhile construction (but be aware that the instructions will be duplicated): <lang Nim>template doWhile(a, b: untyped): untyped =
b while a: b
var val = 0 doWhile val mod 6 != 0:
inc val echo val</lang>
NS-HUBASIC
<lang NS-HUBASIC>10 PRINT "NO,"A" ISN'T A MULTIPLE OF 6." 20 A=A+1 30 IF A-(A/6)*6<>0 THEN GOTO 10 40 PRINT "YES, 6 IS A MULTIPLE OF 6."</lang>
Oberon-2
Works with oo2c Version 2 <lang oberon2> MODULE LoopDoWhile; IMPORT
Out;
PROCEDURE Do(); VAR
i: INTEGER;
BEGIN
i := 0; REPEAT Out.LongInt(i,0);Out.Ln; INC(i) UNTIL (i MOD 6 = 0);
END Do;
BEGIN
Do
END LoopDoWhile. </lang>
Objeck
<lang objeck> i := 0; do {
i += 1; i->PrintLine();
} while (i % 6 <> 0); </lang>
OCaml
OCaml doesn't have a do-while loop, so we can just make a local loop: <lang ocaml>let rec loop i =
let i = succ i in Printf.printf "%d\n" i; if i mod 6 <> 0 then loop i in loop 0</lang>
or implementing a generic do-while iterator with higher order function:
<lang ocaml>let do_while f p =
let rec loop() = f(); if p() then loop() in loop()
(** val do_while : (unit -> 'a) -> (unit -> bool) -> unit *)</lang>
<lang ocaml>let v = ref 0 in do_while (fun () -> incr v; Printf.printf "%d\n" !v)
(fun () -> !v mod 6 <> 0)</lang>
The example above is the an imperative form, below is its functional counterpart: <lang ocaml>let do_while f p ~init =
let rec loop v = let v = f v in if p v then loop v in loop init
do_while (fun v ->
let v = succ v in Printf.printf "%d\n" v; (v)) (fun v -> v mod 6 <> 0) ~init:0</lang>
Or in a very poor OCaml style, we can use an exception to exit a while loop: <lang ocaml>let v = ref 0 exception Exit_loop try while true do
incr v; Printf.printf "%d\n" !v; if not(!v mod 6 <> 0) then raise Exit_loop;
done with Exit_loop -> ()</lang>
Octave
The do-while can be changed into a do-until, just negating the condition of the while. <lang octave>val = 0; do
val++; disp(val)
until( mod(val, 6) == 0 )</lang>
Oforth
<lang Oforth>0 doWhile: [ 1+ dup . dup 6 rem 0 <> ] drop</lang>
OpenEdge/Progress
<lang progress>DEFINE VARIABLE ii AS INTEGER.
DO WHILE ii MODULO 6 <> 0 OR ii = 0:
ii = ii + 1. MESSAGE ii VIEW-AS ALERT-BOX.
END.</lang>
Oz
Normal Oz variables are single-assignment only. So we use a "cell", which is a one-element mutable container. <lang oz>declare
I = {NewCell 0}
in
for until:@I mod 6 == 0 do I := @I + 1 {Show @I} end</lang>
PARI/GP
The generic Pari loops (while
, until
) test at the beginning, so just use an infinite loop with a break.
<lang parigp>x = 0;
while(1,
print(x++); if(x % 6 == 0, break)
)</lang>
If the loop body is something simple then it might be worked into the loop condition. This is obscure but compact.
<lang parigp>x = 0; while (print(x++) || x % 6, )</lang>
The condition in while
and until
is an expression, not a sequence, so ;
for multiple statements cannot be used there.
Pascal
<lang pascal>program countto6(output);
var
i: integer;
begin
i := 0; repeat i := i + 1; writeln(i) until i mod 6 = 0
end.</lang>
Perl
<lang perl>my $val = 0; do {
$val++; print "$val\n";
} while ($val % 6);</lang>
do ... until (condition)
is equivalent to do ... while (not condition)
.
<lang perl>my $val = 0;
do {
$val++; print "$val\n";
} until ($val % 6 == 0);</lang>
Phix
integer x = 0 while 1 do x += 1 ?x if mod(x,6)=0 then exit end if end while
PHL
<lang phl>var i = 0; do { i = i::inc; printf("%i\n", i); } while (i%6 != 0);</lang>
PHP
<lang php>$val = 0; do {
$val++; print "$val\n";
} while ($val % 6 != 0);</lang>
Picat
do while loop
<lang Picat>go =>
N = 0, do N := N+1, println(N) while (N mod 6 != 0).</lang>
Recursion
<lang Picat>go2 =>
do_while(0).
do_while(N) :-
N1 = N + 1, println(N1), N1 mod 6 != 0, do_while(N1).</lang>
Both outputs the same.
- Output:
1 2 3 4 5 6
PicoLisp
Literally: <lang PicoLisp>(let Val 0
(loop (println (inc 'Val)) (T (=0 (% Val 6))) ) )</lang>
Shorter: <lang PicoLisp>(let Val 0
(until (=0 (% (println (inc 'Val)) 6))) )</lang>
or: <lang PicoLisp>(for (Val 0 (n0 (% (println (inc 'Val)) 6))))</lang>
Pike
<lang pike>int main(){
int value = 0; do { value++; write(value + "\n"); } while (value % 6);
}</lang>
PL/I
<lang pli> dcl value fixed bin (31) init (0); do forever;
value = value + 1; if mod(value, 6) = 0 then leave; put list (value);
end; </lang> or shorter: <lang pli>
dcl value fixed bin(31) init(0); do Until(value=6); value+=1; put Skip list(value); end;</lang>
- Output:
1 2 3 4 5 6
Plain English
Plain English has one kind of loop: an infinite loop with (hopefully) a conditional break/exit. So if you want a do-while, put the conditional break/exit at the end of the loop. <lang plainenglish>To run: Start up. Demonstrate do-while. Wait for the escape key. Shut down.
To demonstrate do-while: Bump a counter. Convert the counter to a string. Write the string on the console. If the counter is evenly divisible by 6, exit. Repeat.</lang>
Pop11
<lang pop11>lvars val = 0; while true do
val + 1 -> val; printf(val, '%p\n'); quitif(val rem 6 = 0);
endwhile;</lang>
PowerShell
<lang powershell>$n = 0 do {
$n++ $n
} while ($n % 6 -ne 0)</lang>
Prolog
<lang prolog> % initial condition do(0):- write(0),nl,do(1).
% control condition do(V):- 0 is mod(V,6), !, fail.
% loop do(V) :-
write(V),nl, Y is V + 1, do(Y).
wloop :-
do(0).
</lang>
PureBasic
<lang PureBasic>x=0 Repeat
x+1 Debug x
Until x%6=0</lang>
Python
Python doesn't have a do-while loop. <lang python>val = 0 while True:
val +=1 print val if val % 6 == 0: break</lang>
or repeat the body of the loop before a standard while. <lang python>val = 1 print val while val % 6 != 0:
val += 1 print val</lang>
QB64
CBTJD: 2020/03/14 <lang qbasic>DO
PRINT n n = n + 1
LOOP WHILE n MOD 6 <> 0</lang>
<lang QB64> 'Another demo of DO loops Dim As Integer Counter Print "First loop DO..LOOP UNTIL" Counter = 0 Do
Print Counter Counter = Counter + 1
Loop Until Counter Mod 6 = 0 Print "Counter Mod 6 = "; Counter Mod 6 Print "First loop DO WHILE..LOOP" Counter = 1 Do While Counter Mod 6 <> 0
Print Counter Counter = Counter + 1
Loop Print "Counter Mod 6 = "; Counter Mod 6 End </lang>
Quackery
Quackery's control flow words are mix-and-match. To satisfy this task, we can check for the exit condition at the end of the loop. until
means jump to [
if ToS is false.
<lang quackery>0 [ 1+ dup echo cr
dup 6 mod 0 = until ] drop</lang>
R
<lang R>i <- 0 repeat {
i <- i + 1 print(i) if(i %% 6 == 0) break
}</lang>
Racket
Idiomatic Racket code is functional: <lang racket>
- lang racket
(let loop ([n 0])
(let ([n (add1 n)]) (displayln n) (unless (zero? (modulo n 6)) (loop n))))
</lang>
But an imperative version is easy to do too: <lang racket>
- lang racket
(define n 0) (let loop ()
(set! n (add1 n)) (displayln n) (unless (zero? (modulo n 6)) (loop)))
</lang>
Raku
(formerly Perl 6)
<lang perl6>my $val = 0; repeat {
say ++$val;
} while $val % 6;</lang>
repeat ... until condition
is equivalent to do ... while not condition
.
<lang perl6>my $val = 0; repeat {
say ++$val;
} until $val %% 6;</lang>
(Here we've used %%
, the "divisible-by" operator.)
You can also put the condition before the block, without changing the order of evaluation. <lang perl6>my $val = 0; repeat while $val % 6 { say ++$val; }</lang>
REBOL
<lang REBOL>REBOL [ Title: "Loop/While" URL: http://rosettacode.org/wiki/Loop/Do_While ]
- REBOL doesn't have a specific 'do/while' construct, but 'until' can
- be used to provide the same effect.
value: 0 until [ value: value + 1 print value
0 = mod value 6 ]</lang>
- Output:
1 2 3 4 5 6
Red
<lang Red>Red [] i: 0 until [
?? i i: i + 1 i % 6 = 0 ;; loop , until this is true...
]
</lang>
- Output:
i: 0 i: 1 i: 2 i: 3 i: 4 i: 5
REXX
In the DO UNTIL construct, the expression is evaluated at the end of the DO loop,
even though it is written at the beginning.
This insures that the DO UNTIL loop will execute at least once (as coded below).
In contrast, a DO WHILE construct, the expression would be evaluated at the beginning of the DO loop, and
may cause the DO WHILE loop to not execute at all.
This necessitates the use of DO UNTIL instead of DO WHILE.
version 1
<lang rexx>/*REXX program demonstrates a DO UNTIL construction. */ v=0
do until v//6==0 /*REXX // is the ÷ remainder.*/ v=v+1 say v end /*stick a fork in it, we're done.*/</lang>
- Output:
1 2 3 4 5 6
version 2
<lang rexx>/*REXX program demonstrates a DO UNTIL construction. */
do v=1 until v//6==0 /*REXX // is the ÷ remainder.*/ say v end /*stick a fork in it, we're done.*/</lang>
output is the same as the 1st version.
Ring
<lang ring>
n = 0 While True n++ See n + nl if n % 6 = 0 exit ok end
</lang>
Ruby
The while statement modifier normally checks the condition before entering the loop. But if the while statement modifier is on a begin ... end statement, then it loops at least once. Same with the until statement modifier.
while | until |
---|---|
<lang ruby>val = 0
begin val += 1 puts val end while val % 6 != 0</lang> |
<lang ruby>val = 0
begin val += 1 puts val end until val % 6 == 0</lang> |
During November 2005, Yukihiro Matsumoto, the creator of Ruby, regretted this loop feature and suggested using Kernel#loop.
break unless | break if |
---|---|
<lang ruby>val = 0
loop do val += 1 puts val break unless val %6 != 0 end</lang> |
<lang ruby>val = 0
loop do val += 1 puts val break if val %6 == 0 end</lang> |
All four of these examples print the numbers 1, 2, 3, 4, 5, 6.
Rust
Rust does not have a do...while loop. Instead, the keyword loop is used with a termination condition.
<lang rust>let mut x = 0;
loop {
x += 1; println!("{}", x);
if x % 6 == 0 { break; }
}</lang>
Salmon
<lang Salmon>variable x := 0; do
{ ++x; x! }
while (x % 6 != 0);</lang>
SAS
<lang sas>/* using DO UNTIL so that the loop executes at least once */ data _null_; n=0; do until(mod(n,6)=0);
n+1; put n;
end; run;</lang>
Sather
<lang sather>class MAIN is
main is val ::= 0; loop val := val + 1; #OUT + val + "\n"; while!(val % 6 /= 0) end; end;
end;</lang>
Scala
Imperative
<lang scala> {
var (x, l) = (0, List[Int]()) do { x += 1 l :+= x // A new copy of this list with List(x) appended. } while (x % 6 != 0) l }.foreach(println(_))
</lang>
Tail recursive
<lang scala> def loop(iter: Int, cond: (Int) => Boolean, accu: List[Int]): List[Int] = { val succ = iter + 1 val temp = accu :+ succ if (cond(succ)) loop(succ, cond, temp) else temp } println(loop(0, (_ % 6 != 0), Nil))</lang>
Stream
<lang scala> def loop(i: Int, cond: (Int) => Boolean): Stream[Int] = {
val succ = i + 1; succ #:: (if (cond(succ)) loop(succ, cond) else Stream.empty) } loop(0, (_ % 6 != 0)).foreach(println(_))</lang>
Scheme
<lang scheme>(let loop ((i 1))
(display i) (if (positive? (modulo i 6)) (loop (+ i 1))))</lang>
Scilab
<lang>v=0 while %T
v=v+1 printf("%2d ",v) if modulo(v,6)==0 then break; end
end printf("\n")</lang>
- Output:
1 2 3 4 5 6
Seed7
<lang seed7>$ include "seed7_05.s7i";
const proc: main is func
local var integer: number is 0; begin repeat incr(number); writeln(number) until number rem 6 = 0 end func;</lang>
Sidef
<lang ruby>var value = 0; do {
say ++value;
} while (value % 6);</lang>
Slate
<lang slate>[| val |
val: 0. [val: val + 1. print: val. val \\ 6 ~= 0] whileTrue
] do.</lang>
Smalltalk
<lang smalltalk>|val| val := 0. [
val := val + 1. val displayNl.
] doWhile: [ (val rem: 6) ~= 0 ]</lang>
<lang smalltalk>|val| val := 0. [
val := val + 1. val displayNl.
] doUntil: [ (val rem: 6) == 0 ]</lang>
To simulate the do-while construct, we can use the whileTrue: method of a block with a void while block. <lang smalltalk>|val| val := 0. [
val := val + 1. val displayNl. (val rem: 6) ~= 0
] whileTrue: [ ]</lang>
Or send the loop block a whileTrue message (without argument). <lang smalltalk>|val| val := 0. [
val := val + 1. val displayNl. (val rem: 6) ~= 0
] whileTrue</lang>
Corresponding false-checking messages are whileFalse: and whileFalse (without argument)
Sparkling
<lang sparkling>var i = 0; do {
print(++i);
} while (i % 6 != 0);</lang>
Spin
<lang spin>con
_clkmode = xtal1 + pll16x _clkfreq = 80_000_000
obj
ser : "FullDuplexSerial.spin"
pub main | n
ser.start(31, 30, 0, 115200)
n := 0 repeat n += 1 ser.dec(n) ser.tx(32) while n // 6
waitcnt(_clkfreq + cnt) ser.stop cogstop(0)</lang>
- Output:
1 2 3 4 5 6
SPL
<lang spl>n = 0 >
n += 1 #.output(n)
< n%6</lang>
- Output:
1 2 3 4 5 6
Stata
Stata macro language has no do/while loop, but it's possible to achieve this with a while loop.
Use a flag to force the first loop. It's changed in the loop so that it will have no effect after the first loop.
<lang stata>local n 0 local q 1 while `q' | mod(`n',6) { local q 0 di `++n' }</lang>
Use an infinite while loop and do the test with an if' at the end of the loop.
<lang stata>local n 0 while 1 { di `++n' if mod(`n',6)==0 continue, break }</lang>
Mata
Mata has a do/while loop:
<lang>mata n=0 do { printf("%f\n",++n) } while (mod(n,6)) end</lang>
Suneido
<lang Suneido>val = 0 do
{ Print(++val) } while (val % 6 isnt 0)</lang>
- Output:
1 2 3 4 5 6
Swift
<lang swift>var val = 0 repeat {
val += 1 print(val)
} while val % 6 != 0</lang>
<lang swift>var val = 0 repeat {
val++ print(val)
} while val % 6 != 0</lang>
<lang swift>var val = 0 do {
val++ println(val)
} while val % 6 != 0</lang>
Tailspin
In Tailspin you can loop by sending a value back to the matchers (by "-> #"). Depending on how you set that up, you create different loops. <lang tailspin> templates doWhile
0 -> # <> def val: $ + 1; $val -> !OUT::write $val -> \(<?($ mod 6 <~=0>)> $!\) -> #
end doWhile </lang>
Tcl
Tcl does not have a built-in do...while
construct. This example demonstrates the ease of creating new looping contructs in plain Tcl. do
procedure taken from Tcler's wiki
<lang tcl>proc do {body keyword expression} {
if {$keyword eq "while"} { set expression "!($expression)" } elseif {$keyword ne "until"} { return -code error "unknown keyword \"$keyword\": must be until or while" } set condition [list expr $expression] while 1 { uplevel 1 $body if {[uplevel 1 $condition]} { break } } return
}
set i 0 do {puts [incr i]} while {$i % 6 != 0}</lang>
<lang tcl>package require control set i 0; control::do {puts [incr i]} while {$i % 6 != 0} set i 0; control::do {puts [incr i]} until {$i % 6 == 0}</lang>
Mind you, it is also normal to write this task using a normal while
as:
<lang tcl>set i 0
while true {
puts [incr i] if {$i % 6 == 0} break
}</lang>
TUSCRIPT
<lang tuscript> $$ MODE TUSCRIPT var=0 LOOP var=var+1, rest=var%6 PRINT var IF (rest==0) EXIT ENDLOOP </lang>
- Output:
1 2 3 4 5 6
UNIX Shell
<lang bash>val=0 while true; do
echo $((++val)) [ $((val%6)) -eq 0 ] && break
done</lang>
<lang bash>val=0 while true; do
val=`expr $val + 1` echo $val expr $val % 6 = 0 >/dev/null && break
done</lang>
<lang bash>for ((val=1;;val++)) {
print $val (( val % 6 )) || break
}</lang>
Vala
<lang vala> int a = 0;
do { a++; print(a.to_string() + "\n"); } while ( a % 6 != 0);
</lang>
VBA
<lang VB>Public Sub LoopDoWhile()
Dim value As Integer value = 0 Do value = value + 1 Debug.Print value; Loop While value Mod 6 <> 0
End Sub</lang>
- Output:
1 2 3 4 5 6
Vedit macro language
<lang vedit>#1 = 0 do {
#1++ Num_Type(#1)
} while (#1 % 6 != 0);</lang>
Verbexx
<lang verbexx>// Basic @LOOP until: verb
@LOOP init:{@VAR n = 0} until:(n % 6 == 0) {
n++; @SAY n;
};</lang>
Verilog
<lang Verilog> module main;
integer i;
initial begin i = 1;
$write(i); while(i % 6 != 0) begin i = i + 1; $write(i); end $finish ; end
endmodule </lang>
Visual Basic .NET
<lang vbnet>Dim i = 0 Do
i += 1 Console.WriteLine(i)
Loop Until i Mod 6 = 0</lang>
Wren
Wren doesn't have a do/while loop as such but we can simulate it using an infinite loop with a final conditional break. <lang ecmascript>var v = 0 while (true) {
v = v + 1 System.print(v) if (v%6 == 0) break
}</lang>
- Output:
1 2 3 4 5 6
It can also be simulated without using a break statement as follows: <lang ecmascript>var value = 0 var ok = true while (ok) {
value = value + 1 System.print(value) ok = value%6 != 0
}</lang>
- Output:
Same as before.
Vlang
There is no explicit do-while in Vlang, but it can be simulated with a range-based for loop and the break statement. <lang go>fn main() { mut value := 0 for { value++ println(value)
if value%6 != 0 { break }
} }</lang>
- Output:
1 2 3 4 5 6
It can also be simulated without using a break statement as follows: <lang vlang>fn main() { mut value := 0 for ok := true; ok; ok = value%6 != 0 { value++ println(value) } }</lang>
- Output:
Same as before.
- <lang vlang>fn main() {
// do-while loop 1 mut n1 := 2 for n1 < 6 { n1 *= 2 } println(n1) // prt 8 // do-while loop 2 mut n2 := 2 for ok := true; ok; ok = n2%8 != 0 { n2 *= 2 } println(n2) // prt 8 // do-while loop 3 mut n3 := 2 for { n3 *= 2 if n3 >= 6 { break } } println(n3) // prt 8 }</lang>
X86 Assembly
<lang asm> extern _printf
section .data
output db 0,0
section .text global _main _main:
mov bl, 0 looping: add bl, 0x31 ;0x30 to 0x39 is 0 to 9 in ASCII mov [output], bl sub bl, 0x30 push output call _printf add esp, 4 xor eax, eax xor edx, edx mov al, bl mov ecx, 6 div ecx ; remainder is saved in edx cmp edx, 0 jne looping ; if n & 6 != 0 do looping again xor eax, eax ret
</lang>
XPL0
<lang XPL0>code CrLf=9, IntOut=11; int V; [V:= 0; repeat V:= V+1;
IntOut(0, V); CrLf(0);
until rem(V/6) = 0; ]</lang>
Yorick
<lang yorick>val = 0; do {
val++; write, val;
} while(val % 6 != 0);</lang>
zkl
<lang zkl>val := 0; do {
val+=1; val.print(" ");
} while(val % 6 != 0);</lang>
- Output:
1 2 3 4 5 6
Zig
<lang zig>const std = @import("std");
pub fn main() !void {
var a: u8 = 0; // no do-while in syntax, trust the optimizer to do // correct Loop inversion https://en.wikipedia.org/wiki/Loop_inversion // If the variable `alive` is independent to other variables and not in // diverging control flow, then the optimization is possible in general. var alive = true; while (alive == true or a % 6 != 0) { alive = false; a += 1; try std.io.getStdOut().writer().print("{d}\n", .{a}); }
}</lang>
- Programming Tasks
- Iteration
- Conditional loops
- Simple
- 11l
- 360 Assembly
- 6502 Assembly
- AArch64 Assembly
- Action!
- ActionScript
- Ada
- Agena
- Aime
- ALGOL 60
- ALGOL 68
- ALGOL W
- AmigaE
- ARM Assembly
- AppleScript
- Arturo
- Asymptote
- AutoHotkey
- AWK
- Axe
- BASIC
- Applesoft BASIC
- ASIC
- BaCon
- BASIC256
- BBC BASIC
- Commodore BASIC
- IS-BASIC
- Minimal BASIC
- QBasic
- Run BASIC
- Sinclair ZX81 BASIC
- True BASIC
- XBasic
- Tiny BASIC
- Yabasic
- Bc
- Befunge
- C
- C sharp
- C++
- Chapel
- ChucK
- Clipper
- Clojure
- COBOL
- Coco
- CoffeeScript
- ColdFusion
- Common Lisp
- D
- Dc
- Delphi
- Draco
- Dragon
- DUP
- DWScript
- Dyalect
- E
- Ela
- Elixir
- Emacs Lisp
- Erlang
- ERRE
- Euphoria
- F Sharp
- Factor
- Fantom
- Forth
- Fortran
- Fortress
- FreeBASIC
- Frink
- FutureBasic
- Gambas
- GAP
- GML
- Go
- Groovy
- GW-BASIC
- Harbour
- Haskell
- Haxe
- HolyC
- Icon
- Unicon
- J
- Java
- JavaScript
- Jq
- Julia
- Kotlin
- LabVIEW
- Lasso
- Lambdatalk
- Liberty BASIC
- Lingo
- Lisaac
- LiveCode
- Logo
- Lua
- M2000 Interpreter
- Maple
- Mathematica
- Wolfram Language
- MATLAB
- Octave
- Maxima
- MAXScript
- Metafont
- Microsoft Small Basic
- Min
- MIPS Assembly
- МК-61/52
- Modula-2
- Modula-3
- Monicelli
- MUMPS
- Neko
- Nemerle
- NetRexx
- NewLISP
- Nim
- NS-HUBASIC
- Oberon-2
- Objeck
- OCaml
- Oforth
- OpenEdge/Progress
- Oz
- PARI/GP
- Pascal
- Perl
- Phix
- PHL
- PHP
- Picat
- PicoLisp
- Pike
- PL/I
- Plain English
- Pop11
- PowerShell
- Prolog
- PureBasic
- Python
- QB64
- Quackery
- R
- Racket
- Raku
- REBOL
- Red
- REXX
- Ring
- Ruby
- Rust
- Salmon
- SAS
- Sather
- Scala
- Scheme
- Scilab
- Seed7
- Sidef
- Slate
- Smalltalk
- Sparkling
- Spin
- SPL
- Stata
- Suneido
- Swift
- Tailspin
- Tcl
- Tcllib
- TUSCRIPT
- UNIX Shell
- Vala
- VBA
- Vedit macro language
- Verbexx
- Verilog
- Visual Basic .NET
- Wren
- Vlang
- X86 Assembly
- XPL0
- Yorick
- Zkl
- Zig
- GUISS/Omit
- Commodore BASIC/Omit