Loops/While: Difference between revisions
m
added output
No edit summary |
m (added output) |
||
(42 intermediate revisions by 25 users not shown) | |||
Line 10:
Print the value (with a newline) and divide it by two each time through the loop.
;Related tasks:
Line 20 ⟶ 19:
* [[Loops/For]]
* [[Loops/For with a specified step]]
* [[Loops/Foreach]]
* [[Loops/Increment loop index within loop body]]
* [[Loops/Infinite]]
Line 31 ⟶ 30:
=={{header|0815}}==
<
=={{header|11l}}==
{{trans|Python}}
<
L n > 0
print(n)
n I/= 2</
=={{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
Line 62 ⟶ 61:
WTOLEN DC AL2(8),H'0' length of wto buffer (4+1)
WTOTXT DC CL4' ' wto text
END WHILELOO</
{{out}} (+ sign indicates "problem state" (non system key) issued WTO's
<pre style="height:16ex">
Line 78 ⟶ 77:
</pre>
;Structured Macros
<
WHILELOO CSECT
USING WHILELOO,12 set base register
Line 95 ⟶ 94:
WTOLEN DC AL2(8),H'0' length of wto buffer (4+1)
WTOTXT DC CL4' ' wto text
END WHILELOO</
{{out}}
Same as above
Line 101 ⟶ 100:
=={{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
Line 117 ⟶ 116:
EndLoop: PLA ;restore accumulator from stack
RTS ;return from subroutine</
=={{header|68000 Assembly}}==
Printing routines are left out since this is not the focus of the task.
<syntaxhighlight lang="68000devpac">main:
MOVE.W #1024,D0
WhileLoop:
jsr PrintHexWord
LSR.W #1,D0
BNE WhileLoop</syntaxhighlight>
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program loopwhile64.s */
Line 176 ⟶ 186:
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
{{Output}}
<pre>
Line 192 ⟶ 202:
</pre>
=={{header|Action!}}==
<
CARD i=[1024]
Line 200 ⟶ 210:
i=i/2
OD
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/While.png Screenshot from Atari 8-bit computer]
Line 218 ⟶ 228:
=={{header|ActionScript}}==
<
while (i > 0) {
trace(i);
i /= 2;
}</
=={{header|Ada}}==
<
I : Integer := 1024;
begin
Line 232 ⟶ 242:
I := I / 2;
end loop;
end;</
=={{header|Agena}}==
Tested with Agena 2.9.5 Win32
<
local i := 1024;
while i > 0 do
Line 242 ⟶ 252:
i := i \ 2
od
epocs</
=={{header|Aime}}==
<
i = 1024;
Line 251 ⟶ 261:
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
</syntaxhighlight>
{{Out}}
<pre>
Line 272 ⟶ 282:
{{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
OD</
{{Out}}
<pre>
Line 283 ⟶ 293:
=={{header|ALGOL W}}==
<
integer i;
i := 1024;
Line 291 ⟶ 301:
i := i div 2
end
end.</
=={{header|ALGOL-M}}==
<
integer i;
i := 1024;
Line 301 ⟶ 311:
i := i / 2;
end;
end</
=={{header|Amazing Hopper}}==
<syntaxhighlight lang="c">
#include <jambo.h>
Main
i=1024
Loop
Printnl 'i'
i \= 2
Back if 'i' is positive
End
</syntaxhighlight>
<p>Assembler Hopper code:</p>
<syntaxhighlight lang="amazing hopper">
main:
i=1024
____CODE_JUMP____883612951:,
{i};{"\n"}print;
i\=2
{i},jpos(____CODE_JUMP____883612951),____CODE_JUMP____854411479:,
emptystack?do{{0}};return
</syntaxhighlight>
{{out}}
<pre>
1024
512
256
128
64
32
16
8
4
2
1
</pre>
=={{header|AmbientTalk}}==
Line 307 ⟶ 354:
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
Line 321 ⟶ 368:
i := i / 2
ENDWHILE
ENDPROC</
=={{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
end repeat</
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program loopwhile.s */
Line 455 ⟶ 502:
</syntaxhighlight>
=={{header|ArnoldC}}==
<
HEY CHRISTMAS TREE n
YOU SET US UP 1024
Line 468 ⟶ 515:
ENOUGH TALK
CHILL
YOU HAVE BEEN TERMINATED</
=={{header|Arturo}}==
<
while [i>0] [
print i
i: i/2
]</
{{out}}
Line 491 ⟶ 538:
2
1</pre>
=={{header|Asymptote}}==
<syntaxhighlight lang="asymptote">int i = 1024;
while(i > 0) {
write(i);
i = i # 2; //or also i = quotient(i, 2);
}
//# Integer division; equivalent to quotient(x,y).
//Noting that the Python3 community adopted the comment symbol (//) for integer division, the
//Asymptote community decided to reciprocate and use their comment symbol for integer division!</syntaxhighlight>
=={{header|ATS}}==
With compile-time proof of termination of the loop (which is really a tail recursion).
<
fn
Line 514 ⟶ 574:
implement
main0 () =
loop_while ()</
{{out}}
Line 530 ⟶ 590:
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
Line 546 ⟶ 606:
implement
main0 () =
loop_while ()</
=={{header|AutoHotkey}}==
<
While (i > 0)
{
Line 555 ⟶ 615:
i := Floor(i / 2)
}
MsgBox % output</
=={{header|AWK}}==
<
v = 1024
while(v > 0) {
Line 564 ⟶ 624:
v = int(v/2)
}
}</
=={{header|Axe}}==
<
While A>0
Disp A▶Dec,i
A/2→A
End</
=={{header|Bait}}==
<syntaxhighlight lang="bait">
fun main() {
mut i := 1024
for i > 0 {
println(i)
i = i / 2
}
}
</syntaxhighlight>
=={{header|BASIC}}==
In general, the <code>WHILE</code>-<code>WEND</code> (or <code>DO WHILE</code>-<code>LOOP</code>) statement is used or it is simulated with a construct with conditional jump.
==={{header|ANSI BASIC}}===
{{works with|Decimal BASIC}}
<syntaxhighlight lang="basic">
100 LET
110 DO WHILE I > 0
120 PRINT I
130 LET I = INT(I / 2)
140 LOOP
150 END
</syntaxhighlight>
{{out}}
<pre>
1024
512
256
128
64
32
16
8
4
2
1
</pre>
==={{header|Applesoft BASIC}}===
<
20 IF I% > 0 THEN PRINT I%:I% = I% / 2: GOTO 20</
==={{header|ASIC}}===
<syntaxhighlight lang="basic">
REM Loops/While
Line 598 ⟶ 687:
END
</syntaxhighlight>
{{out}}
<pre>
Line 615 ⟶ 704:
==={{header|BaCon}}===
<syntaxhighlight lang="freebasic">
i = 1024
WHILE i > 0
PRINT i
i = i / 2
WEND</
==={{header|Ballerina}}===
<syntaxhighlight lang="ballerina">int i = 1024;
while i > 0 {
io:println(i);
i = i / 2;
}
</syntaxhighlight>
==={{header|BASIC256}}===
<
while i > 0
Line 631 ⟶ 727:
end while
end</
==={{header|BBC BASIC}}===
{{works with|BBC BASIC for Windows}}
<
WHILE i%
PRINT i%
i% DIV= 2
ENDWHILE</
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
Both loops are equivalent
<syntaxhighlight lang="qbasic">100 i = 1024
110 do while i > 0
120 print i
130 i = int(i/2)
140 loop
150 print
160 i = 1024
170 while i > 0
180 print i
190 i = int(i/2)
200 wend</syntaxhighlight>
==={{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
60 END</
{{out}}
<pre>
Line 666 ⟶ 777:
==={{header|Creative Basic}}===
<
X=1024
Line 692 ⟶ 803:
'Since this is, in fact, a Creative Basic console program.
END</
Note: Spacing is not an issue. I just find the code to be more readable with spaces.
==={{header|FreeBASIC}}===
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64
Dim i As Integer = 1024
While i > 0
Print i
i Shr= 1
Wend
Sleep</syntaxhighlight>
{{out}}
<pre>
1024
512
256
128
64
32
16
8
4
2
1
</pre>
==={{header|FutureBasic}}===
<syntaxhighlight lang="futurebasic">window 1
long i = 1024
while i > 0
print i
i = int( i / 2 )
wend
HandleEvents</syntaxhighlight>
Output:
<pre>
1024
512
256
128
64
32
16
8
4
2
1
</pre>
==={{header|Gambas}}===
'''[https://gambas-playground.proko.eu/?gist=4e992013e4e7dc69a82477299a5ce23a Click this link to run this code]'''
<syntaxhighlight lang="gambas">Public Sub Main()
Dim siCount As Short = 1024
While siCount > 0
Print siCount;;
siCount /= 2
Wend
End</syntaxhighlight>
Output:
<pre>
1024 512 256 128 64 32 16 8 4 2 1
</pre>
==={{header|GW-BASIC}}===
{{works with|BASICA}}
{{works with|Chipmunk Basic}}
{{works with|PC-BASIC|any}}
{{works with|QBasic}}
<syntaxhighlight lang="qbasic">10 I = 1024
20 WHILE I > 0
30 PRINT I
40 i = INT(i/2)
50 WEND
60 END</syntaxhighlight>
==={{header|IS-BASIC}}===
<
110 DO WHILE I>0
120 PRINT I
130 LET I=IP(I/2)
140 LOOP</
==={{header|IWBASIC}}===
<syntaxhighlight lang="iwbasic">
DEF X:INT
X=1024
OPENCONSOLE
WHILE X>0
PRINT X
X=X/2
ENDWHILE
'Output starts with 1024 and ends with 1.
'Putting the following in the loop will produce output starting with 512 and ending with 0:
'X=X/2
'PRINT X
'When compiled as a console only program, a press any key to continue message is automatic.
'I presume code is added by the compiler.
CLOSECONSOLE
'Since this is, in fact, an IWBASIC console program, which compiles and runs.
END</syntaxhighlight>
Note: Spacing is not an issue. I just find the code to be more readable with spaces.
==={{header|Liberty BASIC}}===
All integers are changed to floats if an operation creates a non-integer result.
Without using int() the program keeps going until erroring because accuracy was lost.
{{works with|Just BASIC}}
<syntaxhighlight lang="lb">i = 1024
while i > 0
print i
i = int( i / 2)
wend
end</syntaxhighlight>
==={{header|Microsoft Small Basic}}===
<syntaxhighlight lang="microsoftsmallbasic">
i = 1024
While i > 0
TextWindow.WriteLine(i)
i = Math.Floor(i / 2)
EndWhile
</syntaxhighlight>
==={{header|Minimal BASIC}}===
Minimal BASIC have no <code>while</code> construct. Equivalent using conditional jump:
{{works with|Commodore BASIC}}
{{works with|Nascom ROM BASIC|4.7}}
<syntaxhighlight lang="gwbasic">10 REM Loops/While
20 LET I = 1024
40 IF I <= 0 THEN 80
Line 712 ⟶ 952:
60 LET I = INT(I/2)
70 GOTO 40
80 END</syntaxhighlight>
==={{header|MSX Basic}}===
There is no <code>WHILE</code> construct in MSX Basic. A <code>GOTO</code> construct is used instead.
<syntaxhighlight lang="qbasic">10 I% = 1024
20 IF I% = 0 THEN END
30 PRINT I%
40 I% = I%/2 : rem INT(I/2)
50 GOTO 20</syntaxhighlight>
Solutions [[#GW-BASIC|GW-BASIC]] and [[#Minimal _BASIC|Minimal BASIC]] work without changes.
==={{header|Nascom BASIC}}===
See [[#Minimal BASIC|Minimal BASIC]].
If the repeated sequence is short then the loop can be written in one line.
{{works with|Nascom ROM BASIC|4.7}}
<syntaxhighlight lang="basic">
10 REM Loops/While
20 LET I=1024
30 IF I>0 THEN PRINT I:I=INT(I/2):GOTO 30
40 END
</syntaxhighlight>
==={{header|NS-HUBASIC}}===
<syntaxhighlight lang="ns-hubasic">10 I=1024
20 IF I=0 THEN END
30 PRINT I
40 I=I/2
50 GOTO 20</syntaxhighlight>
==={{header|PureBasic}}===
<syntaxhighlight lang="purebasic">If OpenConsole()
x.i = 1024
While x > 0
PrintN(Str(x))
x / 2
Wend
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
Input()
CloseConsole()
EndIf</syntaxhighlight>
==={{header|QB64}}===
<syntaxhighlight lang="qb64">Dim n As Integer
n = 1024
While n > 0
Print n
n = n \ 2
Wend</syntaxhighlight>
==={{header|QBasic}}===
{{works with|QBasic|1.1}}
Both loops are equivalent
<syntaxhighlight lang="qbasic">i = 1024
WHILE i > 0
PRINT i
i = INT(i / 2)
WEND
PRINT
i = 1024
DO WHILE i > 0
PRINT i
i = i \ 2
LOOP
END</syntaxhighlight>
==={{header|QuickBASIC}}===
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="qbasic">i = 1024
WHILE i > 0
PRINT i
i = i \ 2
WEND</syntaxhighlight>
==={{header|Run BASIC}}===
<syntaxhighlight lang="runbasic">i = 1024
while i > 0
print i
i = int(i / 2)
wend
end</syntaxhighlight>
==={{header|Sinclair ZX81 BASIC}}===
The distinctive thing about a <code>while</code> loop is that the conditional test happens before the loop body, not after—so that the code in the loop may be executed zero times.
Since we have no integer type, we floor the result of the division each time.
<syntaxhighlight lang="basic">10 LET I=1024
20 IF I=0 THEN GOTO 60
30 PRINT I
40 LET I=INT (I/2)
50 GOTO 20</syntaxhighlight>
==={{header|SmallBASIC}}===
<syntaxhighlight lang="qbasic">
i = 1024
WHILE i > 0
PRINT i
i = i \ 2 ' Using \ for integer division instead of /
WEND</syntaxhighlight>
==={{header|TI-83 BASIC}}===
<syntaxhighlight lang="ti83b">1024→I
While I>0
Disp I
I/2→I
End
</syntaxhighlight>
==={{header|TI-89 BASIC}}===
<syntaxhighlight lang="ti89b">Local i
1024 → i
While i > 0
Disp i
intDiv(i, 2) → i
EndWhile</syntaxhighlight>
==={{Header|Tiny BASIC}}===
Tiny BASIC have no <code>while</code> construct. Equivalent using conditional jump:
{{works with|TinyBasic}}
<syntaxhighlight lang="basic">10 REM Loops/While
20 LET I = 1024
30 IF I <= 0 THEN GOTO 70
40 PRINT I
50 LET I = I / 2
60 GOTO 30
70 END</syntaxhighlight>
{{out}}
<pre>
1024
512
256
128
64
32
16
8
4
2
1
</pre>
==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">LET i = 1024
DO WHILE i > 0
PRINT i
LET i = INT(i / 2)
LOOP
END</syntaxhighlight>
==={{header|VBA}}===
<syntaxhighlight lang="vb">Public Sub LoopsWhile()
Dim value As Integer
value = 1024
Do While value > 0
Debug.Print value
value = value / 2
Loop
End Sub</syntaxhighlight>
==={{header|Visual Basic .NET}}===
<syntaxhighlight lang="vbnet">Dim x = 1024
Do
Console.WriteLine(x)
x = x \ 2
Loop While x > 0</syntaxhighlight>
==={{header|Wee Basic}}===
<syntaxhighlight lang="wee basic">let number=1024
while number>0.5
print 1 number
let number=number/2
wend
end</syntaxhighlight>
==={{header|XBasic}}===
{{works with|Windows XBasic}}
<syntaxhighlight lang="xbasic">
i% = 1024
DO WHILE i% > 0
PRINT i%
i% = i% / 2
LOOP
</syntaxhighlight>
==={{header|Yabasic}}===
<syntaxhighlight lang="yabasic">i = 1024
while i > 0
Print i
i = int(i / 2)
wend
end</syntaxhighlight>
=={{header|bc}}==
<
while (i > 0) {
i
i /= 2
}</
=={{header|Befunge}}==
<
^/2,*25.:_@</
=={{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
end</
=={{header|BQN}}==
Line 737 ⟶ 1,170:
BQNcrate's while idiom is the closest equivalent of a while loop in the language.
<
(⌊∘÷⟜2 •Show) _while_ (>⟜0) 1024</
=={{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>:
<
std::cout << i << std::endl;</
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){
Line 795 ⟶ 1,228:
update;
}
}</
=={{header|Caché ObjectScript}}==
<
set x = 1024
while (x > 0) {
Line 805 ⟶ 1,238:
}
quit</
{{out}}<pre>SAMPLES>DO ^WHILELOOP
Line 823 ⟶ 1,256:
=={{header|Chapel}}==
<
while val > 0 {
writeln(val);
val /= 2;
}</
=={{header|ChucK}}==
<syntaxhighlight lang="text">
1024 => int value;
Line 838 ⟶ 1,271:
value / 2 => value;
}
</syntaxhighlight>
=={{header|Clojure}}==
<
(while (> @i 0)
(println @i)
(dosync (ref-set i (quot @i 2))))</
2 ways without mutability:
<
(when (pos? i)
(println i)
Line 856 ⟶ 1,289:
(doseq [i (take-while pos? (iterate #(quot % 2) 1024))]
(println i))</
=={{header|CLU}}==
<
po: stream := stream$primary_output()
n: int := 1024
Line 866 ⟶ 1,299:
n := n/2
end
end start_up</
=={{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.
Line 884 ⟶ 1,317:
GOBACK
.</
=={{header|ColdFusion}}==
Line 890 ⟶ 1,323:
With tags:
<
<cfset i /= 2 />
</cfloop></
With script:
<
while( i > 0 )
{
writeOutput( i + "< br/ >" );
}
</cfscript></
=={{header|Common Lisp}}==
<
(loop while (plusp i) do
(print i)
Line 916 ⟶ 1,349:
(print *i*)
(setf *i* (floor *i* 2)))
</syntaxhighlight>
=={{header|Cowgol}}==
<
var n: uint16 := 1024;
Line 926 ⟶ 1,359:
print_nl();
n := n/2;
end loop;</
=={{header|Crack}}==
<
while( i > 0 ) {
cout ` $i\n`;
i = i/2;
}</
=={{header|Crystal}}==
<
while i > 0
puts i
i //= 2
end</
<code>until ''condition''</code> is the negated version, equivalent to <code>while !(''condition'')</code>.
<
until i <= 0
puts i
i //= 2
end</
=={{header|D}}==
<
void main() {
Line 960 ⟶ 1,393:
i >>= 1;
}
}</
{{out}}
<pre>1024
Line 975 ⟶ 1,408:
=={{header|Dao}}==
<
while( i > 0 ) i = i / 2;</
=={{header|Dart}}==
<syntaxhighlight lang="dart">void main() {
var val = 1024;
while (val > 0) {
print(val);
val >>= 2;
}
}</syntaxhighlight>
Instead of the bitshift operator i >>= 2, you can also use i /= 2 on double variables.
<syntaxhighlight lang="dart">void main() {
num val = 1024;
while (val > 0) {
print(val);
val /= 2;
}
}</syntaxhighlight>
=={{header|Dc}}==
<
=={{header|DCL}}==
Line 986 ⟶ 1,437:
so must make do with IF/THEN/ELSE and GOTO statements.
<
$Loop:
$ IF ( i .LE. 0 ) THEN GOTO LoopEnd
Line 995 ⟶ 1,446:
$ i = i / 2
$ GOTO Loop
$LoopEnd:</
=={{header|Delphi}}==
<syntaxhighlight lang="delphi">var
i : Integer;
begin
Line 1,009 ⟶ 1,460:
i := i div 2;
end;
end;</
=={{header|Draco}}==
<
word i;
i := 1024;
Line 1,019 ⟶ 1,470:
i := i >> 1
od
corp</
{{out}}
<pre>1024
Line 1,034 ⟶ 1,485:
=={{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}
2/\% {2 DIV/MOD SWAP POP}</
Alternative, if the interpreter allows using the shift operator:
<
Output:
<
512
256
Line 1,068 ⟶ 1,519:
4
2
1</
=={{header|DWScript}}==
<
while i > 0 do begin
PrintLn(i);
i := i div 2;
end;</
=={{header|Dyalect}}==
Line 1,083 ⟶ 1,534:
{{trans|Swift}}
<
while i > 0 {
print(i)
i /= 2
}</
=={{header|E}}==
<
while (i > 0) {
println(i)
i //= 2
}</
=={{header|EasyLang}}==
<syntaxhighlight lang="text">i = 1024
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
</syntaxhighlight>
=={{header|EGL}}==
<
while ( x > 0 )
SysLib.writeStdout( x );
x = MathLib.floor( x / 2 );
end</
=={{header|Elena}}==
ELENA
<
{
int i := 1024;
while (i > 0)
{
console.writeLine
i /= 2
}
}</
=={{header|Elixir}}==
<
def while(0), do: :ok
def while(n) do
Line 1,142 ⟶ 1,593:
end
Loops.while(1024)</
=={{header|Emacs Lisp}}==
<
(while (> i 0)
(message "%d" i)
(setq i (/ i 2))))</
=={{header|EMal}}==
<syntaxhighlight lang="emal">
int i = 1024
while i > 0
writeLine(i)
i /= 2
end
</syntaxhighlight>
=={{header|Erlang}}==
<
-export([loop/0]).
Line 1,162 ⟶ 1,622:
loop(N) when N >0 ->
io:format("~w~n", [N]),
loop(N div 2).</
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
I%=1024
WHILE I%>0 DO ! you can leave out >0
Line 1,171 ⟶ 1,631:
I%=I% DIV 2 ! I%=INT(I%/2) for C-64 version
END WHILE
</syntaxhighlight>
=={{header|Euphoria}}==
<
i = 1024
Line 1,180 ⟶ 1,640:
printf(1, "%g\n", {i})
i = floor(i/2) --Euphoria does NOT use integer division. 1/2 = 0.5
end while</
Even without the <code>floor()</code> the code will in fact end. But it's FAR beyond 1.
=={{header|F_Sharp|F#}}==
<
loop 1024</
=={{header|Factor}}==
<
=={{header|FALSE}}==
<
"2/]#%</
=={{header|Fantom}}==
<
{
public static Void main ()
Line 1,207 ⟶ 1,667:
}
}
}</
=={{header|Fennel}}==
<
(while (> i 0)
(print i)
(set i (// n 2)))</
=={{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.
<
while n>2/3 do !!n;n:=n/2; od;</
=={{header|Forth}}==
<
begin dup 0 >
while cr dup . 2/
repeat drop ;
1024 halving</
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<
DO WHILE (i > 0)
WRITE(*,*) i
i = i / 2
END DO</
{{works with|Fortran|77 and later}}
<
INTEGER I
Line 1,251 ⟶ 1,711:
ENDIF
STOP
END</
{{works with|Fortran|IV and 66 and later}}
<
INTEGER I
C FORTRAN 66 does not have IF block.
Line 1,265 ⟶ 1,725:
20 CONTINUE
STOP
END</
=={{header|Fortress}}==
<
component loops_while
export Executable
Line 1,278 ⟶ 1,738:
end
end
</syntaxhighlight>
{{out}}
Line 1,293 ⟶ 1,753:
2
1
</pre>
=={{header|Frink}}==
<
while i>0
{
i = i/1
}</
=={{header|GAP}}==
<
while n > 0 do
Print(n, "\n");
n := QuoInt(n, 2);
od;</
=={{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}}
Line 1,415 ⟶ 1,806:
=={{header|Haskell}}==
<
main = loop 1024
where loop n = when (n > 0)
(do print n
loop (n `div` 2))</
You can use whileM_ function from monad-loops package that operates on monads:
<
import Control.Monad.Loops
Line 1,433 ⟶ 1,824:
(do n <- readIORef r
print n
modifyIORef r (`div` 2))</
With MonadComprehensions extension you can write it a little bit more readable:
<
import Data.IORef
import Control.Monad.Loops
Line 1,446 ⟶ 1,837:
n <- readIORef r
print n
modifyIORef r (`div` 2)</
=={{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}}
Line 1,481 ⟶ 1,872:
=={{header|hexiscript}}==
<
while i > 0
println i
let i (i / 2)
endwhile</
=={{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))
end</
=={{header|Inform 7}}==
<
while N > 0:
say "[N][line break]";
let N be N / 2;</
=={{
Use <code>/</code> for floating-point division, and use <code>(> i 0)</code> for full printing of the sequence (as the output of <code>1</code> here is due to the return of the last <code>while</code> statement).
<syntaxhighlight lang="insitux">
(var i 1024)
(while (> i 1)
(print i)
(var i (// i 2)))
</syntaxhighlight>
{{out}}
<pre>
1024
512
256
128
64
32
16
8
4
2
1
=={{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
Line 1,548 ⟶ 1,939:
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.
Line 1,577 ⟶ 1,968:
:#A conditional function, corresponding to the While test
<
'use strict';
var d = fnDelta(varValue);
Line 1,596 ⟶ 1,987:
}
).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:
<syntaxhighlight lang="javascript">512
256
128
Line 1,609 ⟶ 2,000:
4
2
1</
=={{header|Joy}}==
<
1024 [] [dup putln 2 /] while.</syntaxhighlight>
=={{header|jq}}==
'''Using recurse/1'''<
1024 | recurse( if . > 1 then ./2 | floor else empty end)</
'''Using recurse/2''' (requires jq >1.4)
<
'''Using a filter'''
<
1024|task</
'''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;
_while;</
For example:
<
=={{header|Jsish}}==
<
/* Loops/While in Jsish */
var i = 1024;
Line 1,654 ⟶ 2,044:
1
=!EXPECTEND!=
*/</
{{out}}
Line 1,661 ⟶ 2,051:
=={{header|Julia}}==
<syntaxhighlight lang="julia">
n = 1024
Line 1,668 ⟶ 2,058:
n >>= 1
end
</syntaxhighlight>
{{out}}
<pre>
Line 1,687 ⟶ 2,077:
Implementation of the task using anonymous function is
given below
<syntaxhighlight lang="k">
{while[x>0; \echo x; x%:2]} 1024
</syntaxhighlight>
=={{header|Kotlin}}==
<
fun main(args: Array<String>) {
Line 1,700 ⟶ 2,090:
value /= 2
}
}</
{{out}}
Line 1,722 ⟶ 2,112:
=={{header|Lambdatalk}}==
<
{def loops_while
{lambda {:i}
Line 1,732 ⟶ 2,122:
{loops_while 1024}
-> 1024 512 256 128 64 32 16 8 4 2 1 (end of loop)
</syntaxhighlight>
Alternative solution:
<syntaxhighlight lang="scheme">
{def while
{lambda {:i}
Line 1,767 ⟶ 2,145:
2
1
</syntaxhighlight>
=={{header|Lang}}==
<syntaxhighlight lang="lang">
$n = 1024
while($n > 0) {
fn.println($n)
$n //= 2
}
</syntaxhighlight>
=={{header|
{{trans|Factor}}
<syntaxhighlight lang="lang5">: /i / int ; : 0= 0 == ;
: dip swap '_ set execute _ ; : dupd 'dup dip ;
: 2dip swap '_x set swap '_y set execute _y _x ;
: while
do dupd 'execute 2dip
rot 0= if break else dup 2dip then
loop ;
1024 "dup 0 >" "dup . 2 /i" while</syntaxhighlight>
=={{header|langur}}==
<syntaxhighlight lang="langur">var .i = 1024
while .i > 0 {
writeln .i
.i \= 2
}</
=={{header|Lasso}}==
<
while(#i > 0) => {^
#i + '\r'
#i /= 2
^}</
=={{header|
<syntaxhighlight lang="ldpl">data:
n is number
procedure:
store 1024 in n
while n is greater than 0 do
display n lf
divide n by 2 in n
floor n
repeat</syntaxhighlight>
=={{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
end repeat</
=={{header|Lisaac}}==
<
i := 1024;
{ i > 0 }.while_do {
Line 1,822 ⟶ 2,214:
i := i / 2;
};</
=={{header|LiveCode}}==
<
repeat while n > 0
put n & cr
divide n by 2
end repeat</
=={{header|Logo}}==
<
while [:n > 0] [print :n make "n :n / 2]</
=={{header|LOLCODE}}==
Line 1,839 ⟶ 2,231:
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
Line 1,848 ⟶ 2,240:
IM OUTTA YR loop
KTHXBYE</
=={{header|Lua}}==
<
while n>0 do
print(n)
n = math.floor(n/2)
end</
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module Checkit {
Def long A=1024
Line 1,867 ⟶ 2,259:
}
Checkit
</syntaxhighlight>
One line
<syntaxhighlight lang="m2000 interpreter">
Module Online { A=1024&: While A>0 {Print A: A/=2}} : OnLine
</syntaxhighlight>
=={{header|m4}}==
This ‘loop’ is really a tail recursion, which m4 implementations generally do ''not'' optimize.
<
define(`loop',
Line 1,882 ⟶ 2,274:
divert`'dnl
loop(1024)dnl</
{{out}}
$ m4 loops_while.m4
Line 1,898 ⟶ 2,290:
=={{header|Make}}==
<
MAX=10
Line 1,909 ⟶ 2,301:
%-echo:
@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
Line 1,927 ⟶ 2,319:
4
2
1</
=={{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);
end</
A vectorized version of the code is
<
=={{header|Maxima}}==
<
/* using a C-like loop: divide control variable by two instead of incrementing it */
for n: 1024 next quotient(n, 2) while n > 0 do print(n);</
=={{header|MAXScript}}==
<
while a > 0 do
(
print a
a /= 2
)</
=={{header|Metafont}}==
Line 1,967 ⟶ 2,359:
Metafont has no <tt>while</tt> loop, but it can be "simulated" easily.
<
forever: exitif not (a > 0);
show a;
a := a div 2;
endfor</
=={{header|min}}==
{{works with|min|0.19.3}}
<
=={{header|MiniScript}}==
<
while i > 0
print i
i = floor(i/2)
end while</
{{out}}
Line 2,010 ⟶ 2,393:
=={{header|MIRC Scripting Language}}==
<
var %n = 10
while (%n >= 0) {
Line 2,016 ⟶ 2,399:
dec %n
}
}</
=={{header|MIXAL}}==
<syntaxhighlight lang="mixal">
******************************************
* X = M / N WHILE X > 0
Line 2,049 ⟶ 2,432:
HLT
END START
</syntaxhighlight>
=={{header|МК-61/52}}==
<syntaxhighlight lang="text">1 0 2 4 П0 ИП0 /-/ x<0 15 ИП0
2 / П0 БП 05 С/П</
=={{header|Modula-2}}==
<
IMPORT InOut;
Line 2,068 ⟶ 2,451:
i := i DIV 2
END
END DivBy2.</
=={{header|Modula-3}}==
The usual module code and imports are omitted.
<
VAR i: INTEGER := 1024;
BEGIN
Line 2,080 ⟶ 2,463:
i := i DIV 2;
END;
END DivBy2;</
=={{header|Monte}}==
<syntaxhighlight lang="monte">
var i := 1024
while (i > 0):
traceln(i)
i //= 2
</syntaxhighlight>
=={{header|MOO}}==
<
while (i > 0)
player:tell(i);
i /= 2;
endwhile</
=={{header|Morfa}}==
<
import morfa.io.print;
Line 2,108 ⟶ 2,491:
i /= 2;
}
</syntaxhighlight>
=={{header|Nanoquery}}==
<
while ($n > 0)
println $n
$n = $n/2
end while</
=={{header|Neko}}==
<syntaxhighlight lang="neko">
var i = 1024
Line 2,125 ⟶ 2,508:
i = $idiv(i, 2)
}
</syntaxhighlight>
=={{header|Nemerle}}==
<
while (x > 0)
{
WriteLine($"$x");
x /= 2;
}</
Or, with immutable types, after Haskell:
<
def loop(n : int) : void
{
Line 2,145 ⟶ 2,528:
}
loop(1024)</
=={{header|NetRexx}}==
<
options replace format comments java crossref savelog symbols nobinary
Line 2,158 ⟶ 2,541:
say x_.right(6)
x_ = x_ % 2 -- integer division
end</
=={{header|NewLISP}}==
<
(while (> i 0)
(println i)
(setq i (/ i 2))))</
=={{header|Nim}}==
<
while n > 0:
echo(n)
n = n div 2</
=={{header|Oberon-2}}==
The usual module code and imports are ommited.
<
VAR i: INTEGER;
BEGIN
Line 2,190 ⟶ 2,566:
i := i DIV 2;
END;
END DivBy2;</
=={{header|Objeck}}==
<
while(i > 0) {
i->PrintLine();
i /= 2;
};</
=={{header|ObjectIcon}}==
Line 2,203 ⟶ 2,579:
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()
Line 2,209 ⟶ 2,585:
n := 1024
while n := write(0 < n) / 2
end</
{{out}}
Line 2,226 ⟶ 2,602:
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()
Line 2,236 ⟶ 2,612:
procedure generator(n)
while 0 < n do { suspend n; n /:= 2 }
end</
To show what I mean, let’s do some (merely illustrative) loop-unrolling where the output gets written.
<
procedure main()
Line 2,256 ⟶ 2,632:
procedure generator(n)
while 0 < n do { suspend n; n /:= 2 }
end</
=={{header|OCaml}}==
<
while !n > 0 do
Printf.printf "%d\n" !n;
n := !n / 2
done;;</
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
in loop 1024</
=={{header|Octave}}==
<
while (i > 0)
disp(i)
i = floor(i/2);
endwhile</
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|Odin}}==
Odin only has one loop type: for
<syntaxhighlight lang="odin">
package main
import "core:fmt"
main :: proc() {
for i := 1024 ; i > 0 ; i /= 2 {
fmt.println(i)
}
}
</syntaxhighlight>
=={{header|Oforth}}==
<
=={{header|OOC}}==
<
main: func {
value := 1024
Line 2,295 ⟶ 2,687:
}
}
</syntaxhighlight>
=={{header|Oz}}==
Oz' for-loop can be used in a C-like manner:
<
{Show I}
end</
Alternatively, we can use the <code>while</code> feature of the for-loop with a mutable variable:
<
I = {NewCell 1024}
in
Line 2,310 ⟶ 2,702:
{Show @I}
I := @I div 2
end</
=={{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
</syntaxhighlight>
=={{header|Panoramic}}==
<
x%=1024
Line 2,332 ⟶ 2,724:
rem output starts with 1024 and ends with 1.
terminate</
=={{header|PARI/GP}}==
<
while(n,
print(n);
n/=2
);</
=={{header|Pascal}}==
<
var
Line 2,354 ⟶ 2,746:
i := i div 2
end
end.</
=={{header|PeopleCode}}==
<syntaxhighlight lang="peoplecode">
Local string &CRLF;
Local number &LoopNumber;
Line 2,367 ⟶ 2,759:
&LoopNumber = &LoopNumber / 2;
End-While;
</syntaxhighlight>
=={{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>
Line 2,397 ⟶ 2,789:
<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|Phixmonti}}==
<syntaxhighlight lang="Phixmonti">/# Rosetta Code problem: https://rosettacode.org/wiki/Loops/While
by Galileo, 11/2022 #/
include ..\Utilitys.pmt
1024 dup while dup ? 2 / int dup endwhile</syntaxhighlight>
{{out}}
<pre>1024
512
256
128
64
32
16
8
4
2
1
=== Press any key to exit ===</pre>
=={{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
<syntaxhighlight lang="picat">go =>
N = 1024,
while (N > 0)
println(N),
N := N // 2
end.</syntaxhighlight>
Recursion
{{trans|Prolog}}
<syntaxhighlight lang="picat">go2 =>
while_loop(1024).
while_loop(0) => true.
while_loop(N) =>
println(N),
while_loop(N//2).</syntaxhighlight>
=={{header|PicoLisp}}==
<
(while (gt0 N)
(println N)
(setq N (/ N 2)) ) )</
=={{header|Pike}}==
<
int i = 1024;
while(i > 0){
Line 2,428 ⟶ 2,862:
i = i / 2;
}
}</
=={{header|PL/0}}==
<syntaxhighlight lang="pascal">
var i;
begin
i := 1024;
while i > 0 do
begin
! i;
i := i / 2
end;
end.
</syntaxhighlight>
{{out}}
<pre>
1024
512
256
128
64
32
16
8
4
2
1
</pre>
=={{header|PL/I}}==
<
do while (i>0);
put skip list (i);
i = i / 2;
end;</
=={{header|PL/SQL}}==
{{works with|Oracle}}
<
set serveroutput on
declare
Line 2,451 ⟶ 2,912:
end;
/
</syntaxhighlight>
=={{header|Plain English}}==
<
Start up.
Show the halvings of 1024.
Line 2,465 ⟶ 2,926:
Write the string to the console.
Divide the number by 2.
Repeat.</
=={{header|Pop11}}==
<
while i > 0 do
printf(i, '%p\n');
i div 2 -> i;
endwhile;</
=={{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
Line 2,485 ⟶ 2,946:
2 idiv % divide by two
}
loop</
=={{header|PowerShell}}==
<
while ($i -gt 0) {
$i
$i /= 2
}</
=={{header|Prolog}}==
<
while(X) :-
writeln(X),
X1 is X // 2,
while(X1).</
Start the calculation at a top-level like this:
<syntaxhighlight lang
=={{header|Python}}==
<
while n > 0:
print n
n //= 2</
=={{header|Quackery}}==
<syntaxhighlight lang="quackery">1024
[ dup 0 > while
dup echo cr 2 /
again ]
drop</
{{Out}}
Line 2,558 ⟶ 2,996:
=={{header|R}}==
<
while(i > 0)
{
print(i)
i <- i %/% 2
}</
=={{header|Racket}}==
===Loop/When===
<
(let loop ([n 1024])
(when (positive? n)
(displayln n)
(loop (quotient n 2))))</
===Macro===
<
(define-syntax-rule (while condition body ...)
(let loop ()
Line 2,584 ⟶ 3,022:
(while (positive? n)
(displayln n)
(set! n (sub1 n)))</
=={{header|Raku}}==
Line 2,590 ⟶ 3,028:
Here is a straightforward translation of the task description:
<syntaxhighlight lang="raku"
The same thing with a C-style loop and a bitwise shift operator:
<syntaxhighlight lang="raku"
And here's how you'd <em>really</em> write it, using a sequence operator that intuits the division for you:
<syntaxhighlight lang="raku"
=={{header|REBOL}}==
<
Title: "Loop/While"
URL: http://rosettacode.org/wiki/Loop/While
Line 2,609 ⟶ 3,047:
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.*/
Line 2,630 ⟶ 3,068:
j=j%2 /*in REXX, % is integer division.*/
end
/*stick a fork in it, we're done.*/</
{{out}}
<pre>
Line 2,651 ⟶ 3,089:
::::: '''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.*/
Line 2,657 ⟶ 3,095:
x=x%2 /*in REXX, % is integer division.*/
end
/*stick a fork in it, we're done.*/</
{{out}}
<pre>
Line 2,674 ⟶ 3,112:
===version 3, faster WHILE comparison===
<
x=1024 /*define the initial value of X.*/
do while x>>0 /*this is an exact comparison. */
Line 2,680 ⟶ 3,118:
x=x%2 /*in REXX, % is integer division.*/
end
/*stick a fork in it, we're done.*/</
'''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. */
Line 2,691 ⟶ 3,129:
j=j%2 /*in REXX, % is integer division.*/
end
/*stick a fork in it, we're done.*/</
'''output''' is the same as version 2.
<br><br>
=={{header|Ring}}==
<
i = 1024
while i > 0
Line 2,702 ⟶ 3,140:
i = floor(i / 2)
end
</syntaxhighlight>
=={{header|Rockstar}}==
<syntaxhighlight lang="rockstar">The sky is a television on fire.
The floor is ornamental.
The table is hydrochloric.
While the sky is higher than the floor,
Shout the sky.
Put the sky over the table into the sky.
(Rockstar is known for doing that JavaScript quirk, since all numbers are floats, but due to it having the same limits as JavaScript and the most popular interpreter being JS-based, the loop is finite, yet you don't get the result you would get in something like Python.)</syntaxhighlight>
=={{header|RPL}}==
≪ 1024
'''WHILE''' DUP '''REPEAT'''
DUP 1 DISP
2 /
'''END'''
DROP
≫
=={{header|Ruby}}==
<
while i > 0 do
puts i
i /= 2
end</
The above can be written in one statement:
<
puts i /= 2 while i > 0</
<code>until ''condition''</code> is equivalent to <code>while not ''condition''</code>.
<
until i <= 0 do
puts i
i /= 2
end</
=={{header|Rust}}==
<
let mut n: i32 = 1024;
while n > 0 {
Line 2,737 ⟶ 3,184:
n /= 2;
}
}</
=={{header|SAS}}==
<
n=1024;
do while(n>0);
Line 2,746 ⟶ 3,193:
n=int(n/2);
end;
run;</
=={{header|Sather}}==
<
main is
i ::= 1024;
Line 2,757 ⟶ 3,204:
end;
end;
end;</
=={{header|Scala}}==
{{libheader|Scala}}
===Imperative===
<
while (i > 0) {
println(i)
i /= 2
}</
===Tail recursive===
<
def loop(iter: Int) {
if (iter > 0) {
Line 2,776 ⟶ 3,223:
}
}
loop(1024)</
===Iterator===
<
var i = 1024
def hasNext = i > 0
def next(): Int = { val tmp = i; i = i / 2; tmp }
}
loop.foreach(println(_))</
===Stream===
Finite stream (1024..0) filtered by takeWhile (1024..1).
<
loop(1024).takeWhile(_ > 0).foreach(println(_))</
=={{header|Scheme}}==
<
((<= n 0))
(display n)
(newline))</
=={{header|Scilab}}==
{{works with|Scilab|5.5.1}}
<syntaxhighlight lang="text">i=1024
while i>0
printf("%4d\n",i)
i=int(i/2)
end</
{{out}}
<pre>1024
Line 2,818 ⟶ 3,265:
=={{header|Seed7}}==
<
const proc: main is func
Line 2,828 ⟶ 3,275:
i := i div 2
end while;
end func;</
{{out}}
<pre>
1024
512
256
128
64
32
16
8
4
2
1
</pre>
=={{header|SenseTalk}}==
<
log x
Repeat until x = 1
divide x by 2
log x
End repeat</
=={{header|SETL}}==
<
while n > 0 loop
print( n );
n := n div 2;
end loop;</
=={{header|Sidef}}==
<
while (i > 0) {
say i
i //= 2
}</
=={{header|Simula}}==
{{works with|SIMULA-67}}
<
integer i;
i:=1024;
Line 2,862 ⟶ 3,323:
i:=i//2-1
end
end</
{{out}}
<pre>
1024 511 254 126 62 30 14 6 2
</pre>
=={{header|Slate}}==
<
[n isPositive] whileTrue:
[inform: number printString.
n := n // 2]</
=={{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 ].
[:exit | ... cold ifTrue:[exit value]. ...] loopWithExit</
Examples:
<
[ number > 0 ] whileTrue:
[ Transcript print: number; nl.
number := number // 2 ]</
<
[ number <= 0 ] whileFalse:
[ Transcript print: number; nl.
number := number // 2 ]</
=={{header|Sparkling}}==
<
while i > 0 {
print(i);
i /= 2;
}</
=={{header|Spin}}==
Line 2,916 ⟶ 3,367:
{{works with|HomeSpun}}
{{works with|OpenSpin}}
<
_clkmode = xtal1 + pll16x
_clkfreq = 80_000_000
Line 2,934 ⟶ 3,385:
waitcnt(_clkfreq + cnt)
ser.stop
cogstop(0)</
{{out}}
<pre>
Line 2,941 ⟶ 3,392:
=={{header|SPL}}==
<
>
#.output(n)
n /= 2
< n!<1</
{{out}}
<pre>
Line 2,964 ⟶ 3,415:
{{works with|Db2 LUW}} version 9.7 or higher.
With SQL PL:
<
--#SET TERMINATOR @
Line 2,977 ⟶ 3,428:
END WHILE Loop;
END @
</syntaxhighlight>
Output:
<pre>
Line 3,002 ⟶ 3,453:
=={{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 (
Line 3,017 ⟶ 3,468:
in
loop 1024
end</
=={{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
Line 3,047 ⟶ 3,498:
=={{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
</syntaxhighlight>
=={{header|Tcl}}==
<
while {$i > 0} {
puts $i
set i [expr {$i / 2}]
}</
=={{header|TeX}}==
<
\rosetta=1024
\loop
Line 3,078 ⟶ 3,529:
\ifnum\rosetta > 0
\repeat
\end</
=={{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}}==
<syntaxhighlight lang="transact-sql">
DECLARE @i INT = 1024;
WHILE @i >0
Line 3,116 ⟶ 3,549:
SET @i = @i / 2;
END;
</syntaxhighlight>
=={{header|Trith}}==
<
<
=={{header|TUSCRIPT}}==
<
i=1024
LOOP
Line 3,129 ⟶ 3,562:
i=i/2
IF (i==0) EXIT
ENDLOOP</
{{Out}}
<pre>
Line 3,150 ⟶ 3,583:
=={{header|Uniface}}==
<
numeric I
endvariables
Line 3,158 ⟶ 3,591:
putmess I
I = (I/2)[trunc]
endwhile</
=={{header|UNIX Shell}}==
{{works with|Bourne Again SHell}}
<
while [[ $x -gt 0 ]]; do
echo $x
x=$(( $x/2 ))
done</
=={{header|UnixPipes}}==
<
test $a -gt 0 && (expr $a / 2 >> p.res ; echo $a) || exit 0
done</
=={{header|Ursa}}==
<
set n 1024
Line 3,180 ⟶ 3,613:
out n endl console
set n (int (/ n 2))
end while</
=={{header|Ursala}}==
Line 3,198 ⟶ 3,631:
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 ~&
Line 3,204 ⟶ 3,637:
#show+
main = %nP*=tx g <1024></
{{Out}}
<pre>
Line 3,222 ⟶ 3,655:
The same output is produced by the following main program
using bit manipulation.
<
=={{header|V}}==
<
dup puts
2 / >int
] while</
=={{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}}==
<syntaxhighlight lang="verilog">
module main;
integer i;
Line 3,282 ⟶ 3,705:
end
endmodule
</syntaxhighlight>
=={{header|Vim Script}}==
<
while i > 0
echo i
let i = i / 2
endwhile</
=={{header|
<syntaxhighlight lang="v (vlang)">fn main() {
mut i := 1024
for i > 0 {
Line 3,306 ⟶ 3,722:
i /= 2
}
}</
{{out}}
Line 3,324 ⟶ 3,740:
=={{header|Wart}}==
<
while (i > 0)
prn i
i <- (int i/2)</
=={{header|Whitespace}}==
<
Line 3,354 ⟶ 3,762:
</syntaxhighlight>
Pseudo-assembly equivalent:
<
0:
Line 3,363 ⟶ 3,771:
push 0 swap sub
jn 0
pop exit</
=={{header|Wren}}==
<
while (i > 0) {
System.print(i)
i = (i / 2).floor
}</
{{out}}
Line 3,388 ⟶ 3,796:
=={{header|X86 Assembly}}==
<
; NASM 64 bit X86-64 assembly on Linux
Line 3,429 ⟶ 3,837:
leave ; fix stack
ret ; return
</syntaxhighlight>
=={{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)
(DEFINE I (/ I 2)))</
=={{header|XPL0}}==
<
int I;
[I:= 1024;
Line 3,457 ⟶ 3,855:
I:= I>>1; \(same as I/2 for positive I)
];
]</
=={{header|Z80 Assembly}}==
{{works with|CP/M 3.1|YAZE-AG-2.51.2 Z80 emulator}}
{{works with|ZSM4 macro assembler|YAZE-AG-2.51.2 Z80 emulator}}
Use the /S8 switch on the ZSM4 assembler for 8 significant characters for labels and names
<syntaxhighlight lang="z80">
;
; while loop, dividing 1024 repeatedly by 2, using Z80 assembly language
;
; Runs under CP/M 3.1 on YAZE-AG-2.51.2 Z80 emulator
; Assembled with zsm4 on same emulator/OS, uses macro capabilities of said assembler
; Created with vim under Windows
;
; Thanks to https://wikiti.brandonw.net for the idea for the conversion routine hl -> decimal ASCII
;
;
; 2023-05-19 Xorph
;
;
; Useful definitions
;
bdos equ 05h ; Call to CP/M BDOS function
strdel equ 6eh ; Set string delimiter
wrtstr equ 09h ; Write string to console
nul equ 00h ; ASCII control characters
cr equ 0dh
lf equ 0ah
cnull equ '0' ; ASCII character constants
;
; Macros for BDOS calls
;
setdel macro char ; Set string delimiter to char
ld c,strdel
ld e,char
call bdos
endm
print macro msg ; Output string to console
ld c,wrtstr
ld de,msg
call bdos
endm
newline macro ; Print newline
ld c,wrtstr
ld de,crlf
call bdos
endm
;
; =====================
; Start of main program
; =====================
;
cseg
setdel nul ; Set string delimiter to 00h
ld ix,value ; Register ix points to memory location of counter
while:
ld a,(ix) ; Z80 has no 16 bit compare, so we check the value byte by byte for 0
or a ; In contrast to other CPUs, loading a register does NOT set the flags
jr nz,docalc ; or-ing the accumulator with itself sets the flags and is faster than "cp 0"
ld a,(ix+1)
or a
jr z,endprog ; If both bytes are 0, end program - this jump could be optimized away
; and replaced with a direct "ret z", but we want to simulate a "real"
; while loop, so we continue (jump to) after the last loop statement
docalc:
ld hl,(value) ; Print the current value, followed by newline
ld iy,buffer ; Register iy points to memory location for current value as text for printout
call dispHL ; dispHL modifies iy, so it must be reset to the buffer on every iteration
print buffer
newline
srl (ix+1) ; Neither has the Z80 a 16 bit shift operation for dividing by 2...
rr (ix) ; Shift the MSB of value right and then rotate the LSB with carry to the right
jr while ; Next iteration
endprog:
ret ; Return to CP/M
;
; ===================
; End of main program
; ===================
;
;
; Helper routines - notice that the Z80 does not have a divide instruction
; Notice further that CP/M does not have any support for pretty-printing
; formatted numbers and stuff like that. So we have to do all this by hand...
;
;
; Converts the value (unsigned int) in register hl to its decimal representation
; Register iy has memory address of target for converted value
; String is terminated with nul character (\0)
;
dispHL:
ld b,1 ; Flag for leading '0'
irp x,<-10000,-1000,-100,-10,-1>
ld de,x ; Subtract powers of 10 and determine digit
call calcdig
endm
ld a,nul ; Terminate result string with nul
ld (iy+0),a
ret ; End of conversion routine
calcdig:
ld a,cnull-1 ; Determine the digit character
incrdig:
inc a ; Start with '0'
add hl,de ; As long as subtraction is possible, increment digit character
jr c,incrdig
sbc hl,de ; If negative, undo last subtraction and continue with remainder
cp cnull ; Check for leading '0', these are ignored
jr nz,adddig
bit 0,b ; Use bit instruction for check if flag set, register a contains digit
ret nz ; If '0' found and flag set, it is a leading '0' and we return
adddig:
ld b,0 ; Reset flag for leading '0', we are now outputting digits
ld (iy+0),a ; Store character in memory and set iy to next location
inc iy
ret ; End of conversion helper routine
;
; ================
; Data definitions
; ================
;
dseg
value: defw 1024d ; Starting value for loop, 16 bit little endian
crlf: defb cr,lf,nul ; Generic newline
buffer: defs 10 ; Buffer for conversion of number to text
</syntaxhighlight>
{{out}}
<pre>
E>whilelp
1024
512
256
128
64
32
16
8
4
2
1
</pre>
=={{header|Zig}}==
<syntaxhighlight lang="zig">
const std = @import("std");
Line 3,480 ⟶ 4,037:
std.debug.print("{}\n", .{i});
}
</syntaxhighlight>
=={{header|zkl}}==
<
{{out}}
<pre>
|