Loops/While: Difference between revisions

 

=={{header|0815}}==

 

=={{header|360 Assembly}}==

+1024

+0512

+0001

</pre>

 

=={{header|6502 Assembly}}==

Code is called as a subroutine (i.e. JSR LoopsWhile). Specific OS/hardware routines for printing are left unimplemented.

 

LDA #$00 ;the 6502 is an 8-bit processor

 

EndLoop: PLA ;restore accumulator from stack

 

=={{header|ActionScript}}==

while (i > 0) {

trace(i);

i /= 2;

 

=={{header|Ada}}==

I : Integer := 1024;

begin

I := I / 2;

end loop;

 

=={{header|Aime}}==

 

i = 1024;

o_plan(i, "\n");

i /= 2;

 

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

 

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

WHILE i > 0 DO

print(i);

i := i OVER 2

{{Out}}

<pre>

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

</pre>

 

Both arguments to this message must be blocks (aka anonymous functions or thunks).

 

def i := 1024;

while: { i > 0 } do: {

system.print(" "+i);

i := i/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}}==

i = i / 2

 

{{works with|BBC BASIC for Windows}}

WHILE i%

PRINT i%

i% DIV= 2

 

=={{header|bc}}==

while (i > 0) {

i

i /= 2

 

=={{header|Befunge}}==

 

=={{header|Bracmat}}==

 

=={{header|Brat}}==

Converts to integers so output is a little bit shorter and neater.

 

while { i > 0 } {

p i

i = (i / 2).to_i

 

=={{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|Chapel}}==

while val > 0 {

writeln(val);

val /= 2;

 

=={{header|Clojure}}==

 

(while (> @i 0)

(println @i)

 

2 ways without mutability:

 

(when (pos? i)

(println i)

 

(doseq [i (take-while pos? (iterate #(quot % 2) 1024))]

 

=={{header|COBOL}}==

COBOL does not have a while loop construct, but it is does have a <code>PERFORM UNTIL</code> structure, which means that the normal condition used in a while loop must be negated.

PROGRAM-ID. Loop-While.

 

 

GOBACK

 

=={{header|ColdFusion}}==

 

With tags:

<cfset i /= 2 />

With script:

while( i > 0 )

{

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

}

 

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

 

=={{header|Crack}}==

while( i > 0 ) {

cout ` $i\n`;

i = i/2;

 

 

 

 

=={{header|D}}==

 

void main() {

i >>= 1;

}

{{out}}

<pre>1024

2

1</pre>

 

=={{header|Dc}}==

 

 

=={{header|Delphi}}==

 

i : Integer;

begin

i := i div 2;

end;

 

=={{header|DWScript}}==

 

 

while i > 0 do begin

PrintLn(i);

i := i div 2;

 

=={{header|E}}==

 

while (i > 0) {

println(i)

i //= 2

 

=={{header|EGL}}==

 

while ( x > 0 )

SysLib.writeStdout( x );

x = MathLib.floor( x / 2 );

 

=={{header|Erlang}}==

-export([loop/0]).

 

loop(N) when N >0 ->

io:format("~w~n", [N]),

 

=={{header|Euphoria}}==

i = 1024

 

printf(1, "%g\n", {i})

i = floor(i/2) --Euphoria does NOT use integer division. 1/2 = 0.5

Even without the <code>floor()</code> the code will in fact end. But it's FAR beyond 1.

 

=={{header|F_Sharp|F#}}==

 

=={{header|Factor}}==

 

=={{header|FALSE}}==

 

=={{header|Fantom}}==

 

{

public static Void main ()

}

}

 

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

 

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

INTEGER I

 

GOTO 10

ENDIF

 

 

 

=={{header|Frink}}==

while i>0

{

i = i/1

 

=={{header|GAP}}==

while n > 0 do

Print(n, "\n");

n := QuoInt(n, 2);

 

=={{header|GML}}==

while(i > 0)

{

show_message(string(i))

i /= 2

 

=={{header|Go}}==

for i > 0 {

fmt.Printf("%d\n", i)

i /= 2

 

=={{header|Groovy}}==

Solution:

while (i > 0) {

println i

i /= 2

 

{{Out}}

 

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

 

=={{header|Icon}} and {{header|Unicon}}==

local i

i := 1024

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

 

=={{header|Inform 7}}==

while N > 0:

say "[N][line break]";

 

 

 

 

 

 

 

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

 

Note: this defines an anonymous function (monad define, and the subsequent lines) and passes it the argument 1024, which means it will be executed as soon as the full definition is available.

 

=={{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|LabVIEW}}==

Use Round Towards -Inf to prevent the integer becoming a float.<br/>{{VI snippet}}<br/>

[[File:LabVIEW_Loops_While.png]]

 

=={{header|Lang5}}==

{{trans|Factor}}

: dip swap '_ set execute _ ; : dupd 'dup dip ;

: 2dip swap '_x set swap '_y set execute _y _x ;

loop ;

 

 

 

=={{header|Lasso}}==

while(#i > 0) => {^

#i + '\r'

#i /= 2

 

 

=={{header|Lisaac}}==

i := 1024;

{ i > 0 }.while_do {

i := i / 2;

 

=={{header|Logo}}==

 

=={{header|LOLCODE}}==

LOLCODE's loop semantics require an afterthought if a condition is used, thus the <tt>nop</tt> in the following example. The more idiomatic approach would have been to <tt>GTFO</tt> of the loop once <tt>n</tt> had reached 0.

 

 

I HAS A n ITZ 1024

IM OUTTA YR loop

 

 

=={{header|Lua}}==

while n>0 do

print(n)

n = math.floor(n/2)

 

=={{header|Maple}}==

To avoid generating an infinite sequence (1/2, 1/4, 1/8, 1/16, etc.) of fractions after n takes the value 1, we use integer division (iquo) rather than the solidus operation (/).

1024

512

4

2

 

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:

While[i > 0,

Print[i];

i = Floor[i/2];

 

=={{header|MATLAB}} / {{header|Octave}}==

In Matlab (like Octave) the math is done floating point, then rounding to integer, so that 1/2 will be always 1 and never 0. A 'floor' is used to round the number.

while (i > 0)

disp(i);

i = floor(i/2);

 

A vectorized version of the code is

 

 

=={{header|Maxima}}==

 

/* using a C-like loop: divide control variable by two instead of incrementing it */

 

=={{header|MAXScript}}==

while a > 0 do

(

print a

a /= 2

 

=={{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|MIRC Scripting Language}}==

 

var %n = 10

while (%n >= 0) {

dec %n

}

 

=={{header|МК-61/52}}==

 

=={{header|Modula-2}}==

IMPORT InOut;

 

i := i DIV 2

END

 

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

The usual module code and imports are omitted.

VAR i: INTEGER := 1024;

BEGIN

i := i DIV 2;

END;

 

=={{header|Monte}}==

 

var i := 1024

while (i > 0):

traceln(i)

i //= 2

 

=={{header|MOO}}==

while (i > 0)

player:tell(i);

i /= 2;

 

=={{header|Nemerle}}==

while (x > 0)

{

WriteLine($"$x");

x /= 2;

Or, with immutable types, after Haskell:

def loop(n : int) : void

{

}

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols nobinary

 

say x_.right(6)

x_ = x_ % 2 -- integer division

 

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|Objeck}}==

while(i > 0) {

i->PrintLine();

i /= 2;

 

=={{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|Panoramic}}==

 

x%=1024

rem output starts with 1024 and ends with 1.

 

 

=={{header|PARI/GP}}==

while(n,

print(n);

n/=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|PHL}}==

 

while (i > 0) {

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

i = i/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;

 

=={{header|Pop11}}==

while i > 0 do

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

i div 2 -> i;

 

=={{header|PostScript}}==

{

dup 0 le % check whether still greater than 0

2 idiv % divide by two

}

 

=={{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|Racket}}==

===Loop/When===

(let loop ([n 1024])

(when (positive? n)

(displayln n)

===Macro===

(define-syntax-rule (while condition body ...)

(let loop ()

(loop))))

 

(displayln n)

 

=={{header|Retro}}==

 

=={{header|REXX}}==

===version 1, simple===

j=1024 /*define the initial value of J.*/

do while j>0 /*test if made at the top of DO.*/

j=j%2 /*in REXX, % is integer division.*/

end

1024

512

::::: '''DO WHILE x\==0'''

but that wouldn't be compliant with the wording of the task.

x=1024 /*define the initial value of X.*/

do while x>0 /*test if made at the top of DO.*/

x=x%2 /*in REXX, % is integer division.*/

end

1024

512

 

===version 3, faster WHILE comparison===

x=1024 /*define the initial value of X.*/

do while x>>0 /*this is an exact comparison. */

x=x%2 /*in REXX, % is integer division.*/

end

'''output''' is the same as version 2.

 

===version 4, index reduction===

/* [↓] note: BY defaults to 1*/

do j=1024 by 0 while j>>0 /*this is an exact comparison. */

j=j%2 /*in REXX, % is integer division.*/

end

'''output''' is the same as version 2.

<br><br>

 

=={{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|SAS}}==

n=1024;

do while(n>0);

n=int(n/2);

end;

 

=={{header|Sather}}==

main is

i ::= 1024;

end;

end;

 

=={{header|Scala}}==

{{libheader|Scala}}

===Imperative===

while (i > 0) {

println(i)

i /= 2

===Tail recursive===

def loop(iter: Int) {

println(iter)

loop(iter / 2)

}

}

 

===Iterator===

var i = 1024

def hasNext = i > 0

def next(): Int = { val tmp = i; i = i / 2; tmp }

}

===Stream===

Finite stream (1024..0) filtered by takeWhile (1024..1).

 

=={{header|Scheme}}==

((<= n 0))

(display n)

 

=={{header|Seed7}}==

 

const proc: main is func

i := i div 2

end while;

 

=={{header|Sidef}}==

while (i > 0) {

 

=={{header|Slate}}==

[n isPositive] whileTrue:

[inform: number printString.

 

=={{header|Smalltalk}}==

[ number > 0 ] whileTrue:

[ Transcript print: number; nl.

 

[ number <= 0 ] whileFalse:

[ 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|Suneido}}==

while (i > 0)

{

Print(i)

i = (i / 2).Floor()

{{Out}}

<pre>1024

2

1</pre>

 

=={{header|Tcl}}==

while {$i > 0} {

puts $i

set i [expr {$i / 2}]

 

 

 

=={{header|TorqueScript}}==

This has to make use of mFloor because torque has automatic type shuffling,

causing an infiniteloop.

while(%num > 0)

{

echo(%num);

%num = mFloor(%num / 2);

 

=={{header|Trith}}==

 

=={{header|TUSCRIPT}}==

i=1024

LOOP

i=i/2

IF (i==0) EXIT

{{Out}}

<pre>

=={{header|Unicon}}==

See [[#Icon|Icon]].

 

=={{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+

 

{{Out}}

<pre>

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)

 

=={{header|Vim Script}}==

while i > 0

echo i

let i = i / 2

 

 

=={{header|Wart}}==

while (i > 0)

prn i

 

=={{header|Whitespace}}==

 

 

 

Pseudo-assembly equivalent:

 

0:

push 0 swap sub

jn 0

 

=={{header|XPL0}}==

int I;

[I:= 1024;

I:= I>>1; \(same as I/2 for positive I)

];