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.
You are encouraged to solve this task according to the task description, using any language you may know.
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
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
<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
<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>
Joy
<lang joy> DEFINE putln == put '\n putch.
1024 [0 >] [dup putln 2 /] while. </lang>
Lisaac
<lang Lisaac> + i : INTEGER; i := 1024; { i > 0 }.while_do {
i.print; '\n'.print; i := i / 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>
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) {
print "$n\n"; $n = int $n / 2;
}</lang>
until (condition)
is equivalent to while (not condition)
.
<lang perl>my $n = 1024; until ($n <= 0) {
print "$n\n"; $n = int $n / 2;
}</lang>
Perl 6
<lang perl6>my Int $n = 2 * 1024; while $n = $n div 2 {
say $n;
} </lang>
until condition
is equivalent to while not condition
.
<lang perl6>my Int $n = 2 * 1024; until ($n = $n div 2) <= 0 {
say $n;
}</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;
PowerShell
<lang powershell>$i = 1024 while ($i -gt 0) {
$i $i /= 2
}</lang> Since PowerShell automatically converts variables to other types to accommodate for operations the above loop does not stop at 1 like it would in other languages but loops for quite a while until the value is small enough to be considered 0. An explicit cast corrects this: <lang powershell>$i = 1024 while ($i -gt 0) {
$i [int]$i /= 2
}</lang>
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>
R
<lang R> i <- 1024L while(i > 0) {
print(i) i <- i %/% 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>
TI-89 BASIC
Local i 1024 → i While i > 0 Disp i intDiv(i, 2) → i EndWhile
UNIX 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>
Ursala
Unbounded iteration is expressed with the -> operator. An expression (p-> f) x, where p is a predicate and f is a function, evaluates to x, f(x), or f(f(x)), etc. as far as necessary to falsify p.
Printing an intermediate result on each iteration is a bigger problem because side effects are awkward. Instead, the function g in this example iteratively constructs a list of results, which is displayed on termination.
The argument to g is the unit list <1024>. The predicate p is ~&h, the function that tests whether the head of a list is non-null (equivalent to non-zero). The iterated function f is that which conses the truncated half of the head of its argument with a copy of the whole argument. The main program takes care of list reversal and formatting. <lang Ursala>
- import nat
g = ~&h-> ^C/half@h ~&
- show+
main = %nP*=tx g <1024> </lang> output:
1024 512 256 128 64 32 16 8 4 2 1
Explicit iteration has its uses but there are always alternatives. The same output is produced by the following main program using bit manipulation. <lang Ursala> main = %nP*=tK33 1024 </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>