Loops/While: Difference between revisions

Print the value (with a newline) and divide it by two each time through the loop.

 

;Related tasks:

*   [[Loops/For]]

*   [[Loops/For with a specified step]]

*   [[Loops/Increment loop index within loop body]]

*   [[Loops/Infinite]]

 

=={{header|0815}}==

 

=={{header|11l}}==

{{trans|Python}}

 

L n > 0

print(n)

 

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

;Basic

Using binary arithmetic. Convert results to EBCDIC printable output.

WHILELOO CSECT program's control section

USING WHILELOO,12 set base register

WTOLEN DC AL2(8),H'0' length of wto buffer (4+1)

WTOTXT DC CL4' ' wto text

{{out}} (+ sign indicates "problem state" (non system key) issued WTO's

<pre style="height:16ex">

</pre>

;Structured Macros

WHILELOO CSECT

USING WHILELOO,12 set base register

WTOLEN DC AL2(8),H'0' length of wto buffer (4+1)

WTOTXT DC CL4' ' wto text

{{out}}

Same as above

=={{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|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program loopwhile64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{Output}}

<pre>

</pre>

=={{header|Action!}}==

CARD i=[1024]

 

i=i/2

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/While.png Screenshot from Atari 8-bit computer]

 

=={{header|ActionScript}}==

while (i > 0) {

trace(i);

i /= 2;

 

=={{header|Ada}}==

I : Integer := 1024;

begin

I := I / 2;

end loop;

 

=={{header|Agena}}==

Tested with Agena 2.9.5 Win32

local i := 1024;

while i > 0 do

i := i \ 2

od

 

=={{header|Aime}}==

 

i = 1024;

o_plan(i, "\n");

i /= 2;

 

=={{header|ALGOL 60}}==

The Loops/While structure was in the Algol 60 report of January 1963.

comment Loops/While - algol60 - 21/10/2014;

integer i;

for i:=1024,i div 2 while i>0 do outinteger(1,i)

end

{{Out}}

<pre>

 

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

 

=={{header|ALGOL W}}==

integer i;

i := 1024;

i := i div 2

end

 

=={{header|ALGOL-M}}==

integer i;

i := 1024;

i := i / 2;

end;

 

=={{header|AmbientTalk}}==

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

AppleScript does not natively support a standard out.

Use the Script Editor's Event Log as the output.

repeat while i > 0

log i

set i to i / 2

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program loopwhile.s */

 

 

 

=={{header|ArnoldC}}==

HEY CHRISTMAS TREE n

YOU SET US UP 1024

ENOUGH TALK

CHILL

 

=={{header|Arturo}}==

while [i>0] [

print i

i: i/2

 

{{out}}

 

=={{header|Asymptote}}==

 

while(i > 0) {

//# Integer division; equivalent to quotient(x,y).

//Noting that the Python3 community adopted the comment symbol (//) for integer division, the

 

 

With compile-time proof of termination of the loop (which is really a tail recursion).

 

 

fn

implement

main0 () =

 

{{out}}

 

It is also possible to write an actual ‘while’ loop, although this method requires a variable (the ‘var’ declaration below) and has other problems, and should be used sparingly.

 

fn

implement

main0 () =

 

=={{header|AutoHotkey}}==

While (i > 0)

{

i := Floor(i / 2)

}

 

=={{header|AWK}}==

v = 1024

while(v > 0) {

v = int(v/2)

}

 

=={{header|Axe}}==

While A>0

Disp A▶Dec,i

A/2→A

 

=={{header|BASIC}}==

 

==={{header|Applesoft BASIC}}===

 

==={{header|ASIC}}===

REM Loops/While

 

 

END

{{out}}

<pre>

 

==={{header|BaCon}}===

i = 1024

WHILE i > 0

PRINT i

i = i / 2

 

==={{header|BASIC256}}===

 

while i > 0

end while

 

 

==={{header|BBC BASIC}}===

{{works with|BBC BASIC for Windows}}

WHILE i%

PRINT i%

i% DIV= 2

 

==={{header|Commodore BASIC}}===

There is no WHILE construct in Commodore BASIC. A GOTO construct is used instead. Also, an integer variable name has a % sign as its suffix.

20 IF N% = 0 THEN 60

30 PRINT N%

40 N% = N%/2

50 GOTO 20

{{out}}

<pre>

 

==={{header|Creative Basic}}===

 

X=1024

 

'Since this is, in fact, a Creative Basic console program.

Note: Spacing is not an issue. I just find the code to be more readable with spaces.

 

==={{header|IS-BASIC}}===

110 DO WHILE I>0

120 PRINT I

130 LET I=IP(I/2)

 

==={{header|Minimal BASIC}}===

Minimal BASIC have no <code>while</code> construct. Equivalent using conditional jump:

{{works with|Commodore BASIC}}

20 LET I = 1024

40 IF I <= 0 THEN 80

60 LET I = INT(I/2)

70 GOTO 40

 

==={{header|True BASIC}}===

 

DO WHILE i > 0

LET i = INT(i / 2)

LOOP

 

 

 

=={{header|bc}}==

while (i > 0) {

i

i /= 2

 

=={{header|Befunge}}==

 

=={{header|blz}}==

while num > 1 # blz will automatically cast num to a fraction when dividing 1/2, so this is necessary to stop an infinite loop

print(num)

num = num / 2

 

=={{header|BQN}}==

BQNcrate's while idiom is the closest equivalent of a while loop in the language.

 

 

 

=={{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 sharp|C#}}==

while(i > 0){

System.Console.WriteLine(i);

i /= 2;

 

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

while(i > 0){

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

i /= 2;

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

 

Instead of <code>i /= 2</code> one can also use the bit shift operator <code>i >>= 1</code> on integer variables.

 

Indeed, in C++,

statement;

is equivalent to

init;

while(cond){

update;

}

 

=={{header|Caché ObjectScript}}==

set x = 1024

while (x > 0) {

}

 

{{out}}<pre>SAMPLES>DO ^WHILELOOP

 

=={{header|Chapel}}==

while val > 0 {

writeln(val);

val /= 2;

 

=={{header|ChucK}}==

1024 => int value;

 

value / 2 => value;

}

 

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

po: stream := stream$primary_output()

n: int := 1024

n := n/2

end

 

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

(loop while (plusp i) do

(print i)

(print *i*)

(setf *i* (floor *i* 2)))

 

=={{header|Cowgol}}==

 

var n: uint16 := 1024;

print_nl();

n := n/2;

 

=={{header|Crack}}==

while( i > 0 ) {

cout ` $i\n`;

i = i/2;

 

=={{header|Crystal}}==

while i > 0

puts i

i //= 2

 

<code>until ''condition''</code> is the negated version, equivalent to <code>while !(''condition'')</code>.

 

until i <= 0

puts i

i //= 2

 

=={{header|D}}==

 

void main() {

i >>= 1;

}

{{out}}

<pre>1024

 

=={{header|Dao}}==

 

=={{header|Dc}}==

 

=={{header|DCL}}==

so must make do with IF/THEN/ELSE and GOTO statements.

 

$Loop:

$ IF ( i .LE. 0 ) THEN GOTO LoopEnd

$ i = i / 2

$ GOTO Loop

 

=={{header|Delphi}}==

 

i : Integer;

begin

i := i div 2;

end;

 

=={{header|Draco}}==

word i;

i := 1024;

i := i >> 1

od

{{out}}

<pre>1024

 

=={{header|Dragon}}==

while(i > 0){

showln i

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

 

=={{header|DUP}}==

 

 

Explanation:

[ ][ ]# {while[condition>0][do]}

$ {DUP}

$. {DUP, print top of stack to STDOUT}

10, {print newline}

 

Alternative, if the interpreter allows using the shift operator:

 

 

Output:

 

512

256

4

2

 

=={{header|DWScript}}==

 

 

while i > 0 do begin

PrintLn(i);

i := i div 2;

 

=={{header|Dyalect}}==

{{trans|Swift}}

 

while i > 0 {

print(i)

i /= 2

 

=={{header|E}}==

 

while (i > 0) {

println(i)

i //= 2

 

=={{header|EasyLang}}==

 

while i > 0

print i

i = i div 2

 

=={{header|EchoLisp}}==

(set! n 1024)

(while (> n 0) (write n) (set! n (quotient n 2)))

1024 512 256 128 64 32 16 8 4 2 1

 

=={{header|EGL}}==

 

while ( x > 0 )

SysLib.writeStdout( x );

x = MathLib.floor( x / 2 );

 

=={{header|Elena}}==

{

int i := 1024;

while (i > 0)

{

i /= 2

}

 

=={{header|Elixir}}==

def while(0), do: :ok

def while(n) do

end

 

 

=={{header|Emacs Lisp}}==

(while (> i 0)

(message "%d" i)

 

=={{header|Erlang}}==

-export([loop/0]).

 

loop(N) when N >0 ->

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

 

=={{header|ERRE}}==

I%=1024

WHILE I%>0 DO ! you can leave out >0

I%=I% DIV 2 ! I%=INT(I%/2) for C-64 version

END WHILE

 

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

(while (> i 0)

(print i)

=={{header|Fermat}}==

Note that the test is against something between 1/2 and 1, rather than 0. Otherwise Fermat will continue printing numbers of the form 1/2^n indefinitely.

 

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

 

ENDIF

STOP

 

{{works with|Fortran|IV and 66 and later}}

INTEGER I

C FORTRAN 66 does not have IF block.

20 CONTINUE

STOP

 

=={{header|Fortress}}==

component loops_while

export Executable

end

end

 

{{out}}

2

1

</pre>

 

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

 

You can use whileM_ function from monad-loops package that operates on monads:

 

import Control.Monad.Loops

 

(do n <- readIORef r

print n

 

With MonadComprehensions extension you can write it a little bit more readable:

import Data.IORef

import Control.Monad.Loops

n <- readIORef r

print n

 

=={{header|Haxe}}==

Using shift right.

while (i > 0) {

Sys.println(i);

i >>= 1;

 

Using integer division.

while (i > 0) {

Sys.println(i);

i = Std.int(i / 2);

 

{{out}}

 

=={{header|hexiscript}}==

while i > 0

println i

let i (i / 2)

 

=={{header|HolyC}}==

while (i > 0) {

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

i /= 2;

 

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

while (n > 0) {

print(n);

n /= 2;

 

In a functional idiom of JavaScript, however, we can not use a While '''statement''' to achieve this task, as statements return no value, mutate state, and can not be composed within other functional expressions.

:#A conditional function, corresponding to the While test

 

'use strict';

var d = fnDelta(varValue);

}

).join('\n')

 

If we assume integer division here (Math.floor(x/2)) rather than the floating point division (x/2) used in the imperative example, we obtain the output:

 

256

128

4

2

 

=={{header|Joy}}==

 

=={{header|jq}}==

'''Using recurse/2''' (requires jq >1.4)

'''Using a filter'''

'''Using while/2'''

 

If your jq does not include while/2 as a builtin, here is its definition:

def _while: if cond then ., (update | _while) else empty end;

For example:

 

=={{header|Jsish}}==

/* Loops/While in Jsish */

var i = 1024;

1

=!EXPECTEND!=

 

{{out}}

 

=={{header|Julia}}==

n = 1024

 

n >>= 1

end

{{out}}

<pre>

Implementation of the task using anonymous function is

given below

{while[x>0; \echo x; x%:2]} 1024

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

value /= 2

}

 

{{out}}

 

=={{header|Lambdatalk}}==

{def loops_while

{lambda {:i}

{loops_while 1024}

-> 1024 512 256 128 64 32 16 8 4 2 1 (end of loop)

 

{def while

{lambda {:i}

2

1

 

 

while .i > 0 {

writeln .i

.i \= 2

 

=={{header|Lasso}}==

while(#i > 0) => {^

#i + '\r'

#i /= 2

 

 

=={{header|LIL}}==

 

Backslash is integer division, otherwise LIL would allow the division to go floating point.

 

=={{header|Lingo}}==

repeat while n>0

put n

n = n/2 -- integer division implicitely returns floor: 1/2 -> 0

 

=={{header|Lisaac}}==

i := 1024;

{ i > 0 }.while_do {

i := i / 2;

 

=={{header|LiveCode}}==

repeat while n > 0

put n & cr

divide n by 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|M2000 Interpreter}}==

Module Checkit {

Def long A=1024

}

Checkit

One line

Module Online { A=1024&: While A>0 {Print A: A/=2}} : OnLine

 

=={{header|m4}}==

This ‘loop’ is really a tail recursion, which m4 implementations generally do ''not'' optimize.

 

define(`loop',

 

divert`'dnl

{{out}}

$ m4 loops_while.m4

 

=={{header|Make}}==

MAX=10

 

 

%-echo:

 

Invoking it

 

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

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

{{works with|min|0.19.3}}

 

=={{header|MiniScript}}==

while i > 0

print i

i = floor(i/2)

 

{{out}}

=={{header|MIRC Scripting Language}}==

 

var %n = 10

while (%n >= 0) {

dec %n

}

 

=={{header|MIXAL}}==

******************************************

* X = M / N WHILE X > 0

HLT

END START

 

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

import morfa.io.print;

 

i /= 2;

}

 

=={{header|Nanoquery}}==

while ($n > 0)

println $n

$n = $n/2

 

=={{header|Neko}}==

var i = 1024

 

i = $idiv(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

 

=={{header|NewLISP}}==

(while (> i 0)

(println i)

 

=={{header|Nim}}==

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

An important thing here is the test for termination is a succeed-or-fail operation, rather than a boolean expression. No boolean value is written to the output; rather, the whole statement ''fails'' when '''n''' reaches zero. The expression '''0 < n''' either returns '''n''' or ''fails''.

 

 

procedure main()

n := 1024

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

 

{{out}}

 

The following also works, and shows a way to avoid having to code the method of writing the output into the loop itself.

 

procedure main()

procedure generator(n)

while 0 < n do { suspend n; n /:= 2 }

 

To show what I mean, let’s do some (merely illustrative) loop-unrolling where the output gets written.

 

procedure main()

procedure generator(n)

while 0 < n do { suspend n; n /:= 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|Oforth}}==

 

 

=={{header|OOC}}==

main: func {

value := 1024

}

}

 

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

Panda doesn't have explicit loops, instead we solve it by using the transitive closure operator. It applies a function to each successive value, each unique value is outputted. Our function halves, we make sure that the result is greater than 0 and add newline.

1024.trans(func:half).gt(0) nl

 

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

Local string &CRLF;

Local number &LoopNumber;

&LoopNumber = &LoopNumber / 2;

End-While;

 

=={{header|Perl}}==

while($n){

print "$n\n";

$n = int $n / 2;

 

or written as a for-loop and using the bit-shift operator

 

print "$n\n";

 

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

 

until($n == 0){

print "$n\n";

$n = int $n / 2;

 

=={{header|Phix}}==

<span style="color: #004080;">integer</span> <span style="color: #000000;">i</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1024</span>

<span style="color: #008080;">while</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">0</span> <span style="color: #008080;">do</span>

<span style="color: #000000;">i</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (see note)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>

note: using i=i/2 would iterate over 1000 times until i is 4.94e-324 before the final division made it 0, if it didn't typecheck when it got set to 0.5

 

=={{header|PHL}}==

 

while (i > 0) {

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

i = i/2;

 

=={{header|PHP}}==

while ($i > 0) {

echo "$i\n";

$i >>= 1;

 

=={{header|Picat}}==

While loop

N = 1024,

while (N > 0)

println(N),

N := N // 2

 

Recursion

{{trans|Prolog}}

while_loop(1024).

 

while_loop(N) =>

println(N),

 

=={{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|PL/SQL}}==

{{works with|Oracle}}

set serveroutput on

declare

end;

/

 

=={{header|Plain English}}==

Start up.

Show the halvings of 1024.

Write the string to the console.

Divide the number by 2.

 

=={{header|Pop11}}==

while i > 0 do

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

i div 2 -> i;

 

=={{header|PostScript}}==

PostScript has no real <code>while</code> loop,

but it can easily be created with an endless loop and a check at the beginning:

{

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

while(X) :-

writeln(X),

X1 is X // 2,

 

Start the calculation at a top-level like this:

 

 

=={{header|Python}}==

while n > 0:

print n

 

=={{header|Quackery}}==

[ dup 0 > while

dup echo cr 2 /

again ]

 

{{Out}}

 

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

(while (positive? n)

(displayln n)

 

=={{header|Raku}}==

 

Here is a straightforward translation of the task description:

 

The same thing with a C-style loop and a bitwise shift operator:

 

And here's how you'd <em>really</em> write it, using a sequence operator that intuits the division for you:

 

 

=={{header|REBOL}}==

Title: "Loop/While"

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

print value

value: to-integer value / 2

 

 

=={{header|ReScript}}==

while n.contents > 0 {

Js.log(n.contents)

n := n.contents / 2

 

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

{{out}}

<pre>

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

{{out}}

<pre>

 

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

<br>

 

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

i = 1024

while i > 0

i = floor(i / 2)

end

 

=={{header|Ruby}}==

while i > 0 do

puts i

i /= 2

The above can be written in one statement:

 

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

 

until i <= 0 do

puts i

i /= 2

 

=={{header|Rust}}==

let mut n: i32 = 1024;

while n > 0 {

n /= 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) {

if (iter > 0) {

}

}

 

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

{{works with|Scilab|5.5.1}}

while i>0

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

i=int(i/2)

{{out}}

<pre>1024

 

=={{header|Seed7}}==

 

const proc: main is func

i := i div 2

end while;

 

=={{header|SenseTalk}}==

log x

Repeat until x = 1

divide x by 2

log x

 

=={{header|SETL}}==

while n > 0 loop

print( n );

n := n div 2;

 

=={{header|Sidef}}==

while (i > 0) {

say i

i //= 2

 

=={{header|Simula}}==

{{works with|SIMULA-67}}

integer i;

i:=1024;

i:=i//2-1

end

{{out}}

<pre>

 1024  511  254  126   62   30   14    6    2 

</pre>

 

=={{header|Slate}}==

[n isPositive] whileTrue:

[inform: number printString.

 

=={{header|Smalltalk}}==

The Block (aka lambda closure) class provides a number of loop messages; with test at begin, test at end and with exit (break).

 

[foo notNil] whileTrue: [s next. ...].

[...] doWhile: [ ... someBooleanExpression ].

[...] doUntil: [ ... someBooleanExpression ].

 

Examples:

[ number > 0 ] whileTrue:

[ Transcript print: number; nl.

 

[ number <= 0 ] whileFalse:

[ Transcript print: number; nl.

 

=={{header|Sparkling}}==

while i > 0 {

print(i);

i /= 2;

 

=={{header|Spin}}==

{{works with|HomeSpun}}

{{works with|OpenSpin}}

_clkmode = xtal1 + pll16x

_clkfreq = 80_000_000

waitcnt(_clkfreq + cnt)

ser.stop

{{out}}

<pre>

 

=={{header|SPL}}==

>

#.output(n)

n /= 2

{{out}}

<pre>

{{works with|Db2 LUW}} version 9.7 or higher.

With SQL PL:

--#SET TERMINATOR @

 

END WHILE Loop;

END @

Output:

<pre>

 

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

while `n'>0 {

display `n'

local n=floor(`n'/2)

 

=={{header|Suneido}}==

while (i > 0)

{

Print(i)

i = (i / 2).Floor()

{{Out}}

<pre>1024

 

=={{header|Swift}}==

while i > 0 {

println(i)

i /= 2

 

=={{header|Tailspin}}==

In Tailspin you can loop by sending a value back to the matchers (by "-> #"). Depending on how you set that up, you create different loops.

1024 -> \(

<0~..> '$;$#10;' -> !OUT::write

$ ~/ 2 -> #

\) -> !VOID

 

=={{header|Tcl}}==

while {$i > 0} {

puts $i

set i [expr {$i / 2}]

 

=={{header|TeX}}==

 

\rosetta=1024

\loop

\ifnum\rosetta > 0

\repeat

 

=={{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|Transact-SQL}}==

DECLARE @i INT = 1024;

WHILE @i >0

SET @i = @i / 2;

END;

 

=={{header|Trith}}==

 

=={{header|TUSCRIPT}}==

i=1024

LOOP

i=i/2

IF (i==0) EXIT

{{Out}}

<pre>

=={{header|Uniface}}==

 

numeric I

endvariables

putmess I

I = (I/2)[trunc]

 

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

set n 1024

 

out n endl console

set n (int (/ n 2))

 

=={{header|Ursala}}==

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.

 

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

while (i > 0) {

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

i /= 2;

 

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

while (#1 > 0) {

Num_Type(#1)

#1 /= 2

or with for loop:

Num_Type(#1)

 

=={{header|Verbexx}}==

 

@LOOP init:{@VAR n = 1024} while:(n > 0) next:{n /= 2}

{

@SAY n;

 

 

=={{header|Verilog}}==

module main;

integer i;

end

endmodule

 

 

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

while i > 0

echo i

let i = i / 2

 

mut i := 1024

for i > 0 {

i /= 2

}

 

{{out}}

 

=={{header|Wart}}==

while (i > 0)

prn i

 

=={{header|Whitespace}}==

 

 

 

Pseudo-assembly equivalent:

 

0:

push 0 swap sub

jn 0

 

=={{header|Wren}}==

while (i > 0) {

System.print(i)

i = (i / 2).floor

 

{{out}}

 

=={{header|X86 Assembly}}==

; NASM 64 bit X86-64 assembly on Linux

 

leave ; fix stack

ret ; return

 

=={{header|XLISP}}==

The specification calls for an integer value and for the loop to run <tt>WHILE</tt> that value is greater than zero. In a dynamically typed language like XLISP, variables cannot be declared as integer or real; but the same result is obtained by looping <tt>WHILE</tt> the value of the variable <i>i</i> is greater than or equal to one.

 

(WHILE (>= I 1)

(PRINT I)

 

=={{header|XPL0}}==

int I;

[I:= 1024;

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

];

 

 

 

 

 

=={{header|Zig}}==

const std = @import("std");

 

std.debug.print("{}\n", .{i});

}

=={{header|zkl}}==

{{out}}

<pre>