Loops/Do-while

Loops/Do-while
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.

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>

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>

Aime

<lang aime>integer a;

a = 0; do {

  a += 1;
  o_integer(a);
  o_byte('\n');

} while (a % 6 != 0);</lang>

ALGOL 68

<lang algol68>FOR value WHILE

 print(value);

1. WHILE # value MOD 6 /= 0 DO

 SKIP

OD</lang>

AmigaE

<lang amigae>PROC main()

 DEF i = 0
 REPEAT
   i := i + 1
   WriteF('\d\n', i)
 UNTIL Mod(i, 6) = 0

ENDPROC</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>

BASIC

Works with: QuickBasic version 4.5

<lang qbasic>a = 0 do

 a = a + 1
 print a

loop while a mod 6 <> 0</lang>

BBC BASIC

<lang bbcbasic>a = 0 REPEAT

 a = a + 1
 PRINT a

UNTIL a MOD 6 = 0</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 cpp>int val = 0; do{

  val++;
  cout << val << endl;

}while(val % 6 != 0);</lang>

C#

<lang csharp>int a = 0;

do {

   Console.WriteLine(a);
   a += 1;

} while (a % 6 != 0);</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>(setq 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>

Clojure

<lang Clojure>(loop [i 0]

 (let [i* (inc i)]
   (println i*)
   (when-not (zero? (mod i* 6))
     (recur i*))))</lang>

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

Translation of: bc

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

DWScript

<lang Delphi> var i := 0;

repeat

  Inc(i);
  PrintLn(i);

until i mod 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 console

loop n | n % 6 == 0 = out $ ()

      | else = out $ loop (n+1)
       where out = (& writen n)</lang>

This implementation uses a thunk to represent a console output. Output is not done in the initialization of 'out' variable, it is done when 'out' calculation is forced by a '$' operator (sequencing operator).

Erlang

<lang Erlang> do() -> io:format("0~n"), do(1).

do(N) when N rem 6 =:= 0 -> io:format("~w~n", [N]); do(N) -> io:format("~w~n", [N]), do(N+1). </lang>

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

Works with: Fortran version 90 and later

<lang fortran>INTEGER :: i = 0 DO

 i = i + 1
 WRITE(*, *) i
 IF (MOD(i, 6) == 0) EXIT

END DO</lang>

Works with: Fortran version 77 and later

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

Go

No do-while in Go. <lang go>package main

import "fmt"

func main() {

   for value := 0;; {
       value++
       fmt.Println(value)
       if value % 6 == 0 {
           break
       }
   }

}</lang> Output:

1
2
3
4
5
6

GML

<lang GML>i = 0 do

   {
   i += 1
   show_message(string(i))
   }

until (i mod 6 = 0)</lang>

Groovy

Groovy does not have a bottom-checking loop construct! So 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

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>

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

<lang javascript>var val = 0; do {

 print(++val);

} while (val % 6);</lang>

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.

Liberty BASIC

<lang lb> a = 0 do

 a =a +1
 print a

loop until ( a mod 6) = 0 </lang>

Lisaac

<lang Lisaac>+ val : INTEGER; {

 val := val + 1;
 val.print;
 '\n'.print;
 val % 6 != 0

}.while_do { };</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>

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>

Mathematica

<lang Mathematica>value = 5; NestWhile[

 # + 1 &
 ,
 value
 , (Print[#]; Mod[#, 6] != 0) &
 ];</lang>

gives back: <lang Mathematica>5 6</lang> If the starting value is 6, only 6 is returned.

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>

Modula-2

<lang modula2>MODULE DoWhile;

 IMPORT InOut;

 VAR
   i: INTEGER;

BEGIN

 i := 0
 REPEAT
   InOut.WriteInt(i, 1);
   InOut.WriteLn;
   INC(i)
 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>

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>

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>

Objeck

<lang objeck> i := 0; do {

  i += 1;
  i->PrintLine();

} while (i % 6 <> 0); </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>

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(val % 6 == 0, break)

)</lang>

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>

Perl 6

Works with: Rakudo Star version 2010.08

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

PHP

<lang php>$val = 0; do {

  $val++;
  print "$val\n";

} while ($val % 6 != 0);</lang>

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>

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

Works with: PureBasic version 4.41

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

R

<lang R>i <- 0 repeat {

  i <- i + 1
  print(i)
  if(i %% 6 == 0) break

}</lang>

REBOL

<lang REBOL>REBOL [ Title: "Loop/While" Author: oofoe Date: 2009-12-19 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

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 evaulated at the beginning of the DO loop, and may cause the DO WHILE loop to not execute at all. <lang rexx>v=0

 do until v//6==0        /*    //  is modulus in REXX.*/
 v=v+1
 say v
 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.

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=n+1;
 put n;

end; run;</lang>

Sather

Translation of: C

<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

<lang scala>var x=0 do {

 println(x)
 x+=1

} while(x%6!=0)</lang>

Scheme

<lang scheme>(let loop ((i 1))

 (display i)
 (if (positive? (modulo i 6))
     (loop (+ i 1))))</lang>

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>

Slate

<lang slate>[| val |

 val: 0.
 [val: val + 1.
  print: val.
  val \\ 6 ~= 0] whileTrue

] do.</lang>

Smalltalk

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>

Suneido

<lang Suneido>val = 0 do

   {
   Print(++val)
   } while (val % 6 isnt 0)</lang>

Output:

<lang Suneido>1 2 3 4 5 6</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>

Library: Tcllib (Package: control)

<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

Works with: bash

Works with: pdksh

Works with: zsh

<lang bash>val=0 while true; do

 echo $((++val))
 [ $((val%6)) -eq 0 ] && break

done</lang>

Works with: Bourne Shell

<lang bash>val=0 while true; do

 val=`expr $val + 1`
 echo $val
 expr $val % 6 = 0 >/dev/null && break

done</lang>

Vedit macro language

<lang vedit>#1 = 0 do {

   #1++
   Num_Type(#1)

} while (#1 % 6 != 0);</lang>

Visual Basic .NET

<lang vbnet>Dim i = 0 Do

   i += 1
   Console.WriteLine(i)

Loop Until i Mod 6 = 0</lang>

Yorick

<lang yorick>val = 0; do {

   val++;
   write, val;

} while(val % 6 != 0);</lang>