Loops/While

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

: 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

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

</lang>

Haskell

import Control.Monad
main = loop 1024      
  where loop n = when (n > 0)
                      (do print n
                          loop (n `div` 2))

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

  ,. <.@-:^:*^: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).

  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>

Logo

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>

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>$n = 1024; while ($n > 0) {

   print "$n\n";
   $n >>= 1; # also acceptable: use integer; $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>

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>

UnixPipes

(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

V

1024 [0 >] [
   dup puts
   2 / >int
] while

Visual Basic .NET

       Dim x = 1024
       Do
           Console.WriteLine(x)
           x = x \ 2
       Loop While x > 0