Loops/While: Difference between revisions

 

=={{header|ActionScript}}==

while (i > 0) {

trace(i);

i /= 2;

 

=={{header|Ada}}==

I : Integer := 1024;

begin

I := I / 2;

end loop;

 

=={{header|ALGOL 68}}==

WHILE i > 0 DO

i := i OVER 2

 

=={{header|AmigaE}}==

DEF i = 1024

WHILE i > 0

i := i / 2

ENDWHILE

 

=={{header|AppleScript}}==

repeat while i > 0

log i

set i to i / 2

 

=={{header|AutoHotkey}}==

While (i > 0)

{

i := Floor(i / 2)

}

 

=={{header|AWK}}==

v = 1024

while(v > 0) {

v = int(v/2)

}

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

while i > 0

print i

 

=={{header|Befunge}}==

 

 

=={{header|C}}==

while(i > 0) {

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

i /= 2;

In for loop fashion:

for(i = 1024;i > 0; i/=2){

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

 

=={{header|C++}}==

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

i /= 2;

Alternatively, it can be done with <code>for</code>:

Indeed, in C++,

is equivalent to

init;

statement;

update;

}

 

 

=={{header|Clojure}}==

 

=={{header|ColdFusion}}==

 

With tags:

<cfset i /= 2 />

With script:

while( i > 0 )

{

writeOutput( i + "< br/ >" );

}

 

=={{header|Common Lisp}}==

 

=={{header|D}}==

 

void main() {

i >>= 1;

}

 

=={{header|E}}==

 

while (i > 0) {

println(i)

i //= 2

 

=={{header|Factor}}==

 

=={{header|FALSE}}==

 

=={{header|Forth}}==

begin dup 0 >

while cr dup . 2/

repeat drop ;

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

DO WHILE (i > 0)

WRITE(*,*) i

i = i / 2

 

=={{header|Haskell}}==

main = loop 1024

where loop n = when (n > 0)

(do print n

 

 

 

main :: IO ()

main = do r <- newIORef 1024

return (n > 0))

print n

 

local i

i := 1024

while write(0 < (i := i / 2))

 

=={{header|J}}==

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

 

 

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

 

while. 0 < y do.

smoutput y

end.

i.0 0

 

=={{header|Java}}==

while(i > 0){

System.out.println(i);

i >>= 1; //also acceptable: i /= 2;

With a for loop:

System.out.println(i);

 

=={{header|JavaScript}}==

 

=={{header|Joy}}==

 

 

=={{header|Lisaac}}==

i := 1024;

{ i > 0 }.while_do {

i := i / 2;

 

=={{header|Logo}}==

 

=={{header|Lua}}==

while n>0 do

print(n)

n = math.floor(n/2)

 

 

 

 

=={{header|Make}}==

MAX=10

 

 

%-echo:

 

Invoking it

 

=={{header|Metafont}}==

Metafont has no <tt>while</tt> loop, but it can be "simulated" easily.

 

forever: exitif not (a > 0);

show a;

a := a div 2;

 

=={{header|Modula-3}}==

The usual module code and imports are omitted.

VAR i: INTEGER := 1024;

BEGIN

i := i DIV 2;

END;

 

=={{header|MOO}}==

while (i > 0)

player:tell(i);

i /= 2;

 

while n > 0:

echo(n)

 

=={{header|Oberon-2}}==

The usual module code and imports are ommited.

VAR i: INTEGER;

BEGIN

i := i DIV 2;

END;

 

=={{header|OCaml}}==

while !n > 0 do

Printf.printf "%d\n" !n;

n := !n / 2

 

But it is more common to write it in a tail-recursive functional style:

if n > 0 then begin

Printf.printf "%d\n" n;

loop (n / 2)

end

 

=={{header|Octave}}==

while (i > 0)

disp(i)

i = floor(i/2);

 

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.

 

=={{header|Oz}}==

Oz' for-loop can be used in a C-like manner:

{Show I}

 

Alternatively, we can use the <code>while</code> feature of the for-loop with a mutable variable:

I = {NewCell 1024}

in

{Show @I}

I := @I div 2

 

=={{header|Pascal}}==

 

var

i := i div 2

end

 

=={{header|Perl}}==

print "$n\n";

$n = int $n / 2;

 

<code>until (''condition'')</code> is equivalent to <code>while (not ''condition'')</code>.

 

print "$n\n";

$n = int $n / 2;

 

 

 

 

 

=={{header|PHP}}==

while ($i > 0) {

echo "$i\n";

$i >>= 1;

 

=={{header|PicoLisp}}==

(while (gt0 N)

(println N)

 

=={{header|Pike}}==

int i = 1024;

while(i > 0){

i = i / 2;

}

 

=={{header|PL/I}}==

 

do while (i>0);

put skip list (i);

i = i / 2;

end;

 

=={{header|Pop11}}==

while i > 0 do

printf(i, '%p\n');

i div 2 -> i;

 

=={{header|PowerShell}}==

while ($i -gt 0) {

$i

$i /= 2

 

=={{header|Prolog}}==

 

=={{header|Python}}==

while n > 0:

print n

 

=={{header|R}}==

while(i > 0)

{

print(i)

i <- i %/% 2

 

=={{header|REBOL}}==

Title: "Loop/While"

URL: http://rosettacode.org/wiki/Loop/While

]

print value

value: to-integer value / 2

 

=={{header|REXX}}==

 

=={{header|Ruby}}==

while i > 0 do

puts i

i /= 2

 

<code>until ''condition''</code> is equivalent to <code>while not ''condition''</code>.

 

until i <= 0 do

puts i

i /= 2

 

=={{header|Scheme}}==

((<= n 0))

(display n)

 

=={{header|Seed7}}==

 

const proc: main is func

i := i div 2

end while;

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

[ number > 0 ] whileTrue:

[ Transcript print: number; nl.

 

=={{header|Standard ML}}==

while !n > 0 do (

print (Int.toString (!n) ^ "\n");

n := !n div 2

 

But it is more common to write it in a tail-recursive functional style:

fun loop n =

if n > 0 then (

in

loop 1024

 

=={{header|Tcl}}==

while {$i > 0} {

puts $i

set i [expr {$i / 2}]

 

 

 

=={{header|UNIX Shell}}==

{{works with|Bourne Again SHell}}

while [[ $x -gt 0 ]]; do

echo $x

x=$(( $x/2 ))

 

=={{header|UnixPipes}}==

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

 

=={{header|Ursala}}==

 

Printing an intermediate result on each iteration is a bigger problem

 

 

g = ~&h-> ^C/half@h ~&

#show+

 

<pre>

1024

The same output is produced by the following main program

using bit manipulation.

 

=={{header|V}}==

dup puts

2 / >int

 

=={{header|Vedit macro language}}==

while (#1 > 0) {

Num_Type(#1)

#1 /= 2

or with for loop:

Num_Type(#1)