Loops/While

From Rosetta Code
< Loops
Revision as of 17:38, 22 July 2009 by rosettacode>Luke-Jr (MOO)
Task
Loops/While
You are encouraged to solve this task according to the task description, using any language you may know.

Start an integer value at 1024. Loop while it is greater than 0. Print the value (with a newline) and divide it by two each time through the loop.

ActionScript

<lang actionscript> var i:int = 1024; while (i > 0) { 

   trace(i);
   i /= 2;

} </lang>

Ada

<lang ada> declare 

  I : Integer := 1024;

begin 

  while I > 0 loop
     Put_Line(Integer'Image(I));
     I := I / 2;
  end loop;

end; </lang>

ALGOL 68

Works with: ALGOL 68 version Standard - no extensions to language used
Works with: ALGOL 68G version Any - tested with release mk15-0.8b.fc9.i386
Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386
INT i := 1024;
WHILE i > 0 DO
   print((i));
   i := i OVER 2
OD

Output: 

      +1024       +512       +256       +128        +64        +32        +16         +8         +4         +2         +1

AmigaE

<lang amigae>PROC main() 

 DEF i = 1024
 WHILE i > 0
   WriteF('\d\n', i)
   i := i / 2
 ENDWHILE

ENDPROC</lang>

AutoHotkey

<lang AutoHotkey> i = 1024 While (i > 0) { 

 output = %output%`n%i%
 i := Floor(i / 2)

} MsgBox % output </lang>

AWK

<lang awk>BEGIN { 

 v = 1024
 while(v > 0) {
   print v
   v = int(v/2)
 }

}</lang>

BASIC

Works with: QuickBasic version 4.5

<lang qbasic>i = 1024 while i > 0 

  print i
  i = i / 2

wend</lang>

Befunge

84*:*>   :v
     ^/2.:_@


C

<lang c>int i = 1024; while(i > 0) { 

 printf("%d\n", i);
 i /= 2;

}</lang> In for loop fashion: <lang c>int i; for(i = 1024;i > 0; i/=2){ 

  printf("%d\n", i);

}</lang>

C++

<lang cpp>int i = 1024; while(i > 0) { 

 std::cout << i << std::endl;
 i /= 2;

}</lang> Alternatively, it can be done with for: <lang cpp> for (int i = 1024; i>0; i /= 2) 

 std::cout << i << std::endl;

</lang> Indeed, in C++, <lang cpp> for (init; cond; update) 

 statement;

</lang> is equivalent to <lang cpp> { 

 init;
 while (cond)
 {
   statement;
   update;
 }

} </lang>

C#

<lang c>int i = 1024; while(i > 0){ 

  System.Console.WriteLine(i);
  i /= 2;

}</lang>

ColdFusion

Remove the leading space from the line break tag.

With tags: 

<cfset i = 1024 />
<cfloop condition="i GT 0">
  #i#< br />
  <cfset i /= 2 />
</cfloop>

With script: 

<cfscript>
  i = 1024;
  while( i > 0 )
  {
    writeOutput( i + "< br/ >" );
  }
</cfscript>

Common Lisp

<lang lisp>(setq i 1024) (loop while (> i 0) do 

 (print i)
 (setq i (floor i 2)))</lang>

D

<lang d>import std.stdio;

int i = 1024; void main() { 

   while(i > 0) {
       writefln("%s", i);
       i >>= 1;
   }

}</lang>

E

<lang e>var i := 1024 while (i > 0) { 

   println(i)
   i //= 2

}</lang>

FALSE

1024[$0>][$."
"2/]#%

Forth

<lang forth> 

: halving ( n -- )
  begin  dup 0 >
  while  cr dup .  2/
  repeat drop ;
1024 halving

</lang>

Factor

 1024 [ dup 0 > ] [ dup . 2 /i ] [ drop ] while

Fortran

Works with: Fortran version 90 and later

<lang fortran> 

INTEGER :: i = 1024
DO WHILE (i > 0)
  WRITE(*,*) i
  i = i / 2
END DO

</lang>

Haskell

<lang haskell>import Control.Monad (when) main = loop 1024 

 where loop n = when (n > 0)
                     (do print n
                         loop (n `div` 2))</lang>

You could try to write a "while" that operates on monads:

<lang haskell>import Control.Monad (when)

whileM :: (Monad m) => m Bool -> m a -> m () whileM cond body = do c <- cond 

                     when c (body >> whileM cond body)</lang>

You can use it like this

<lang haskell>import Data.IORef

main :: IO () main = do r <- newIORef 1024 

         whileM (do n <- readIORef r
                    return (n > 0))
                (do n <- readIORef r
                    print n
                    modifyIORef r (`div` 2))</lang>

Icon

<lang icon> 

procedure main()
   local i
   i := 1024
   while write(0 < (i := i / 2))
end

</lang>

J

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

<lang j> 

  ,. <.@-:^:*^:a: 1024

</lang>

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

       while. 0 < y do.
            y 1!:2 ] 2
            y =. <. -: y 
       end.

      i. 0 0
  )

</lang>

Though it's rare to see J code like this.

Java

<lang java5>int i = 1024; while(i > 0){ 

  System.out.println(i);
  i >>= 1; //also acceptable: i /= 2;

}</lang> With a for loop: <lang java5>for(int i = 1024; i > 0;i /= 2 /*or i>>= 1*/){ 

  System.out.println(i);

}</lang>

JavaScript

<lang javascript>var n = 1024; while (n>0) { 

print(n);
n/=2;

}</lang> 

make "n 1024
while [:n > 0] [print :n  make "n :n / 2]

Mathematica

Mathematica does not support integer-rounding, it would result in getting fractions: 1/2, 1/4 , 1/8 and so on; the loop would take infinite time without using the Floor function: <lang Mathematica> 

i = 1024;
While[i > 0,
 Print[i];
 i = Floor[i/2];
]

</lang>

MAXScript

a = 1024
while a > 0 do
(
    print a
    a /= 2
)

Make

NEXT=`expr $* / 2`
MAX=10

all: $(MAX)-n;

0-n:;

%-n: %-echo
       @-make -f while.mk $(NEXT)-n MAX=$(MAX)

%-echo:
       @echo $*

Invoking it 

|make -f while.mk MAX=1024

Metafont

Metafont has no a while loop, but it can be "simulated" easily.

<lang metafont>a := 1024; forever: exitif not (a > 0); 

 show a;
 a := a div 2;

endfor</lang>

Modula-3

The usual module code and imports are omitted. <lang modula3>PROCEDURE DivBy2() = 

 VAR i: INTEGER := 1024;
 BEGIN
   WHILE i > 0 DO
     IO.PutInt(i);
     IO.Put("\n");
     i := i DIV 2;
   END;
 END DivBy2;</lang>

MOO

<lang moo> i = 1024; while (i > 0) 

 player:tell(i);
 i /= 2;

endwhile</lang>

Oberon-2

The usual module code and imports are ommited. <lang oberon2>PROCEDURE DivBy2*(); 

 VAR i: INTEGER;

BEGIN 

 i := 1024;
 WHILE i > 0 DO
   Out.Int(i,0);
   Out.Ln;
   i := i DIV 2;
 END;

END DivBy2;</lang>

OCaml

<lang ocaml>let n = ref 1024;; while !n > 0 do 

 Printf.printf "%d\n" !n;
 n := !n / 2

done;;</lang>

But it is more common to write it in a tail-recursive functional style: <lang ocaml>let rec loop n = 

 if n > 0 then begin
   Printf.printf "%d\n" n;
   loop (n / 2)
 end

in loop 1024</lang>

Octave

<lang octave>i = 1024; while (i > 0) 

 disp(i)
 i = floor(i/2);

endwhile</lang>

The usage of the type int32 is not convenient, since the math is done floating point, then rounding to integer, so that 1/2 will be always 1 and never 0.

Pascal

<lang pascal> program divby2(output);

var 

 i: integer;

begin 

 i := 1024;
 while i > 0 do
   begin
     writeln(i);
     i := i div 2
   end

end. </lang>

Perl

<lang perl>my $n = 1024; while ($n > 0) { 

   print "$n\n";
   $n >>= 1; # also acceptable: use integer; $n /= 2;

}</lang> The until loop is equivalent to while (not condition) <lang perl>my $n = 1024; until ($n <= 0) { 

   print "$n\n";
   $n /= 2;

}</lang>

PHP

<lang php>$i = 1024; while ($i > 0) { 

  echo "$i\n";
  $i >>= 1;

}</lang>

Pop11

lvars i = 1024;
while i > 0 do
    printf(i, '%p\n');
    i div 2 -> i;
endwhile;

Prolog

<lang prolog>while(0) :- !. while(X) :- write(X), nl, X1 is X // 2, while(X1).</lang>

Python

<lang python>n = 1024 while n > 0: 

   print n
   n //= 2</lang>

Ruby

<lang ruby>i = 1024 while i > 0 do 

  puts i
  i /= 2

end</lang> Ruby also has a "while" statement modifier: <lang ruby>i = 1024 begin puts i; i /= 2; end while i > 0</lang> The above can be written in one statement (using the return value of the Kernel#puts method: nil is false), but the readability suffers: <lang ruby>i = 1024 puts i or i /= 2 while i > 0</lang>

Scheme

<lang scheme> (do ((n 1024 (quotient n 2))) 

   ((<= n 0))
   (display n)
   (newline))</lang>

Slate

<lang slate> [| n | n: 1024. 

 [n isPositive] whileTrue: 
   [inform: number printString.
    n: n // 2]] do

</lang>

Smalltalk

<lang smalltalk>number := 1024. [ number > 0 ] whileTrue: 

 [ Transcript print: number; nl.
 number := number // 2 ]</lang>

Standard ML

<lang sml>val n = ref 1024; while !n > 0 do ( 

 print (Int.toString (!n) ^ "\n");
 n := !n div 2

)</lang>

But it is more common to write it in a tail-recursive functional style: <lang sml>let 

 fun loop n =
   if n > 0 then (
     print (Int.toString n ^ "\n");
     loop (n div 2)
   ) else ()

in 

 loop 1024

end</lang>

Tcl

<lang tcl>set i 1024 while {$i > 0} { 

   puts $i
   set i [expr {$i / 2}]

}</lang>

UNIX Shell

Works with: Bourne Again SHell

<lang bash>x=1024 while $x -gt 0 ; do 

 echo $x
 x=$(( $x/2 ))

done</lang>

UnixPipes

<lang sh> (echo 1024>p.res;tail -f p.res) | while read a ; do 

   test $a -gt 0 && (expr $a / 2  >> p.res ; echo $a) || exit 0
done</lang>

V

<lang v> 1024 [0 >] [ 

   dup puts
   2 / >int
] while</lang>

Vedit macro language

<lang vedit>#1 = 1024 while (#1 > 0) { 

   Num_Type(#1)
   #1 /= 2

} </lang> or with for loop: <lang vedit>for (#1 = 1024; #1 > 0; #1 /= 2) { 

   Num_Type(#1)

}</lang>

Visual Basic .NET

<lang vbnet>Dim x = 1024 Do 

   Console.WriteLine(x)
   x = x \ 2

Loop While x > 0</lang>

Retrieved from "https://rosettacode.org/wiki/Loops/While?oldid=67818"