Loops/While: Difference between revisions
m →{{header|REXX}}: changed condition to match task. -- ~~~~ |
m →{{header|REXX}}: showed J & X are both integers. -- ~~~~ |
||
Line 879: | Line 879: | ||
===version 2=== |
===version 2=== |
||
<lang rexx>/*REXX program to show a DO WHILE construct. */ |
<lang rexx>/*REXX program to show a DO WHILE construct. */ |
||
x=1024 |
|||
do while |
do while x>0 |
||
say right( |
say right(x,10) |
||
x=x%2 /*in REXX, % is integer division. */ |
|||
end</lang> |
end</lang> |
||
'''output''' |
'''output''' |
Revision as of 02:05, 26 May 2012
You are encouraged to solve this task according to the task description, using any language you may know.
Start an integer value at 1024. Loop while it is greater than 0. Print the value (with a newline) and divide it by two each time through the loop.
6502 Assembly
Code is called as a subroutine (i.e. JSR LoopsWhile). Specific OS/hardware routines for printing are left unimplemented. <lang 6502asm>LoopsWhile: PHA ;push accumulator onto stack
LDA #$00 ;the 6502 is an 8-bit processor STA Ilow ;and so 1024 ($0400) must be stored in two memory locations LDA #$04 STA Ihigh WhileLoop: LDA Ilow BNE NotZero LDA Ihigh BEQ EndLoop NotZero: JSR PrintI ;routine not implemented LSR Ihigh ;shift right ROR Ilow ;rotate right JMP WhileLoop
EndLoop: PLA ;restore accumulator from stack RTS ;return from subroutine</lang>
ActionScript
<lang actionscript>var i:int = 1024; while (i > 0) {
trace(i); i /= 2;
}</lang>
Ada
<lang ada>declare
I : Integer := 1024;
begin
while I > 0 loop Put_Line(Integer'Image(I)); I := I / 2; end loop;
end;</lang>
ALGOL 68
<lang algol68>INT i := 1024; WHILE i > 0 DO
print(i); i := i OVER 2
OD</lang> Output:
+1024 +512 +256 +128 +64 +32 +16 +8 +4 +2 +1
AmigaE
<lang amigae>PROC main()
DEF i = 1024 WHILE i > 0 WriteF('\d\n', i) i := i / 2 ENDWHILE
ENDPROC</lang>
AppleScript
AppleScript does not natively support a standard out. Use the Script Editor's Event Log as the output. <lang AppleScript >set i to 1024 repeat while i > 0 log i set i to i / 2 end repeat</lang>
AutoHotkey
<lang AutoHotkey>i = 1024 While (i > 0) {
output = %output%`n%i% i := Floor(i / 2)
} MsgBox % output</lang>
AWK
<lang awk>BEGIN {
v = 1024 while(v > 0) { print v v = int(v/2) }
}</lang>
BASIC
<lang qbasic>i = 1024 while i > 0
print i i = i / 2
wend</lang>
Befunge
<lang befunge>84*:*> :v
^/2.:_@</lang>
Brat
Converts to integers so output is a little bit shorter and neater.
<lang brat>i = 1024 while { i > 0 } {
p i i = (i / 2).to_i
}</lang>
C
<lang c>int i = 1024; while(i > 0) {
printf("%d\n", i); i /= 2;
}</lang> In for loop fashion: <lang c>int i; for(i = 1024;i > 0; i/=2){
printf("%d\n", i);
}</lang>
C++
<lang cpp>int i = 1024; while(i > 0) {
std::cout << i << std::endl; i /= 2;
}</lang>
Alternatively, it can be done with for
:
<lang cpp>for (int i = 1024; i>0; i /= 2)
std::cout << i << std::endl;</lang>
Indeed, in C++, <lang cpp>for (init; cond; update)
statement;</lang>
is equivalent to <lang cpp>{
init; while (cond) { statement; update; }
}</lang>
C#
<lang csharp>int i = 1024; while(i > 0){
System.Console.WriteLine(i); i /= 2;
}</lang>
Clojure
<lang lisp>(def i (ref 1024))
(while (> @i 0)
(println @i) (dosync (ref-set i (quot @i 2))))</lang>
2 ways without mutability:
<lang Clojure>(loop [i 1024]
(when (pos? i) (println i) (recur (quot i 2))))
(doseq [i (take-while pos? (iterate #(quot % 2) 1024))]
(println i))</lang>
ColdFusion
Remove the leading space from the line break tag.
With tags: <lang cfm><cfset i = 1024 /> <cfloop condition="i GT 0">
#i#< br /> <cfset i /= 2 />
</cfloop></lang> With script: <lang cfm><cfscript>
i = 1024; while( i > 0 ) { writeOutput( i + "< br/ >" ); }
</cfscript></lang>
Common Lisp
<lang lisp>(setq i 1024) (loop while (> i 0) do
(print i) (setq i (floor i 2)))</lang>
D
<lang d>import std.stdio;
void main() {
int i = 1024;
while (i > 0) { writeln(i); i >>= 1; }
}</lang>
- Output:
1024 512 256 128 64 32 16 8 4 2 1
Delphi
<lang Delphi>var
i : Integer;
begin
i := 1024;
while i > 0 do begin Writeln(i); i := i div 2; end;
end;</lang>
DWScript
<lang Delphi>var i := 1024;
while i > 0 do begin
PrintLn(i); i := i div 2;
end;</lang>
E
<lang e>var i := 1024 while (i > 0) {
println(i) i //= 2
}</lang>
Euphoria
<lang Euphoria> integer i i = 1024
while i > 0 do
printf(1, "%g\n", {i}) i = floor(i/2) --Euphoria does NOT use integer division. 1/2 = 0.5
end while
</lang>
Even without the floor()
the code will in fact end. But it's FAR beyond 1.
Factor
<lang factor>1024 [ dup 0 > ] [ dup . 2 /i ] while drop</lang>
FALSE
<lang false>1024[$0>][$." "2/]#%</lang>
Fantom
<lang fantom> class Main {
public static Void main () { Int i := 1024 while (i > 0) { echo (i) i /= 2 } }
} </lang>
Forth
<lang forth>: halving ( n -- )
begin dup 0 > while cr dup . 2/ repeat drop ;
1024 halving</lang>
Fortran
<lang fortran>INTEGER :: i = 1024 DO WHILE (i > 0)
WRITE(*,*) i i = i / 2
END DO</lang>
<lang fortran> PROGRAM LOOPWHILE
INTEGER I
C FORTRAN 77 does not have a while loop, so we use GOTO statements C with conditions instead. This is one of two easy ways to do it.
I = 1024 10 CONTINUE
C Check condition.
IF (I .GT. 0) THEN
C Handle I.
WRITE (*,*) I I = I / 2
C Jump back to before the IF block.
GOTO 10 ENDIF
C This is an alternative while loop with labels on both ends. This C will use the condition as a break rather than create an entire C IF block. Which you use is up to you, but be aware that you must C use this one if you plan on allowing for breaks.
I = 1024 20 CONTINUE
C If condition is false, break.
IF (I .LE. 0) GOTO 30
C Handle I.
WRITE (*,*) I I = I / 2
C Jump back to the "loop" beginning.
GOTO 20 30 CONTINUE
STOP END</lang>
GML
<lang GML>i = 1024 while(i > 0)
{ show_message(string(i)) i /= 2 }</lang>
Go
<lang go>i := 1024 for i > 0 {
fmt.Printf("%d\n", i) i /= 2
}</lang>
Groovy
Solution: <lang groovy>int i = 1024 while (i > 0) {
println i i /= 2
}</lang>
Output:
1024 512 256 128 64 32 16 8 4 2 1
Haskell
<lang haskell>import Control.Monad (when) main = loop 1024
where loop n = when (n > 0) (do print n loop (n `div` 2))</lang>
You could try to write a "while" that operates on monads:
<lang haskell>import Control.Monad (when)
whileM :: (Monad m) => m Bool -> m a -> m () whileM cond body = do c <- cond
when c (body >> whileM cond body)</lang>
You can use it like this
<lang haskell>import Data.IORef
main :: IO () main = do r <- newIORef 1024
whileM (do n <- readIORef r return (n > 0)) (do n <- readIORef r print n modifyIORef r (`div` 2))</lang>
Icon and Unicon
<lang icon>procedure main()
local i i := 1024 while write(0 < (i := i / 2))
end</lang>
Inform 7
<lang inform7>let N be 1024; while N > 0: say "[N][line break]"; let N be N / 2;</lang>
J
J is array-oriented, so there is very little need for loops. For example, one could satisfy this task this way:
<lang j>,. <.@-:^:*^:a: 1024</lang>
J does support loops for those times they can't be avoided (just like many languages support gotos for those time they can't be avoided).
<lang j>monad define 1024
while. 0 < y do. smoutput y y =. <. -: y end. i.0 0
)</lang>
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.
Java
<lang java5>int i = 1024; while(i > 0){
System.out.println(i); i >>= 1; //also acceptable: i /= 2;
}</lang> With a for loop: <lang java5>for(int i = 1024; i > 0;i /= 2 /*or i>>= 1*/){
System.out.println(i);
}</lang>
JavaScript
<lang javascript>var n = 1024; while (n>0) {
print(n); n/=2;
}</lang>
Joy
<lang joy>DEFINE putln == put '\n putch.
1024 [] [dup putln 2 /] while.</lang>
LabVIEW
Use Round Towards -Inf to prevent the integer becoming a float.
This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.
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. <lang lb> i = 1024 while i > 0
print i i = int( i / 2)
wend end </lang>
Lisaac
<lang Lisaac>+ i : INTEGER; i := 1024; { i > 0 }.while_do {
i.println; i := i / 2;
};</lang>
Logo
<lang logo>make "n 1024 while [:n > 0] [print :n make "n :n / 2]</lang>
Lua
<lang lua> n = 1024 while n>0 do
print(n) n = math.floor(n/2)
end </lang>
Mathematica
Mathematica does not support integer-rounding, it would result in getting fractions: 1/2, 1/4 , 1/8 and so on; the loop would take infinite time without using the Floor function: <lang Mathematica>i = 1024; While[i > 0,
Print[i]; i = Floor[i/2];
]</lang>
MATLAB / 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. <lang Matlab>i = 1024; while (i > 0)
disp(i); i = floor(i/2);
end</lang>
A vectorized version of the code is
<lang Matlab> printf('%d\n', 2.^[log2(1024):-1:0]); </lang>
Maxima
<lang maxima>block([n], n: 1024, while n > 0 do (print(n), n: quotient(n, 2)));
/* 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);</lang>
MAXScript
<lang maxscript>a = 1024 while a > 0 do (
print a a /= 2
)</lang>
Make
<lang make>NEXT=`expr $* / 2` MAX=10
all: $(MAX)-n;
0-n:;
%-n: %-echo
@-make -f while.mk $(NEXT)-n MAX=$(MAX)
%-echo:
@echo $*</lang>
Invoking it <lang make>|make -f while.mk MAX=1024</lang>
Metafont
Metafont has no while loop, but it can be "simulated" easily.
<lang metafont>a := 1024; forever: exitif not (a > 0);
show a; a := a div 2;
endfor</lang>
MIRC Scripting Language
<lang mirc>alias while_loop {
var %n = 10 while (%n >= 0) { echo -a Countdown: %n dec %n }
}</lang>
Modula-2
<lang modula2>MODULE DivBy2;
IMPORT InOut;
VAR i: INTEGER;
BEGIN
i := 1024; WHILE i > 0 DO InOut.WriteInt(i, 4); InOut.WriteLn; i := i DIV 2 END
END DivBy2.</lang>
Modula-3
The usual module code and imports are omitted. <lang modula3>PROCEDURE DivBy2() =
VAR i: INTEGER := 1024; BEGIN WHILE i > 0 DO IO.PutInt(i); IO.Put("\n"); i := i DIV 2; END; END DivBy2;</lang>
MOO
<lang moo>i = 1024; while (i > 0)
player:tell(i); i /= 2;
endwhile</lang>
NetRexx
<lang NetRexx>/* NetRexx */ options replace format comments java crossref savelog symbols nobinary
say say 'Loops/While'
x_ = 1024 loop while x_ > 0 say x_.right(6) x_ = x_ % 2 -- integer division end
</lang>
Nimrod
<lang python>var n: int = 1024 while n > 0:
echo(n) n = n div 2</lang>
Nemerle
<lang Nemerle>mutable x = 1024; while (x > 0) {
WriteLine($"$x"); x /= 2;
}</lang> Or, with immutable types, after Haskell: <lang Nemerle> // within another function, eg Main() def loop(n : int) : void {
when (n > 0) { WriteLine($"$n"); loop(n / 2); }
}
loop(1024)</lang>
Oberon-2
The usual module code and imports are ommited. <lang oberon2>PROCEDURE DivBy2*();
VAR i: INTEGER;
BEGIN
i := 1024; WHILE i > 0 DO Out.Int(i,0); Out.Ln; i := i DIV 2; END;
END DivBy2;</lang>
Objeck
<lang objeck> i := 1024; while(i > 0) {
i->PrintLine(); i /= 2;
}; </lang>
OCaml
<lang ocaml>let n = ref 1024;; while !n > 0 do
Printf.printf "%d\n" !n; n := !n / 2
done;;</lang>
But it is more common to write it in a tail-recursive functional style: <lang ocaml>let rec loop n =
if n > 0 then begin Printf.printf "%d\n" n; loop (n / 2) end
in loop 1024</lang>
Octave
<lang octave>i = 1024; while (i > 0)
disp(i) i = floor(i/2);
endwhile</lang>
The usage of the type int32 is not convenient, since the math is done floating point, then rounding to integer, so that 1/2 will be always 1 and never 0.
Oz
Oz' for-loop can be used in a C-like manner: <lang oz>for I in 1024; I>0; I div 2 do
{Show I}
end</lang>
Alternatively, we can use the while
feature of the for-loop with a mutable variable:
<lang oz>declare
I = {NewCell 1024}
in
for while:@I > 0 do {Show @I} I := @I div 2 end</lang>
PARI/GP
<lang parigp>n=1024; while(n,
print(n); n/=2
);</lang>
Pascal
<lang pascal>program divby2(output);
var
i: integer;
begin
i := 1024; while i > 0 do begin writeln(i); i := i div 2 end
end.</lang>
Perl
<lang perl>my $n = 1024; while ($n) {
print "$n\n"; $n = int $n / 2;
}</lang>
until (condition)
is equivalent to while (not condition)
.
<lang perl>my $n = 1024; until ($n <= 0) {
print "$n\n"; $n = int $n / 2;
}</lang>
Perl 6
Note that +> is the Perl 6 right bit-shift operator, it is equivalent to dividing by two. The + indicates that it is a numeric operation, and the > indicates that it is the right bit-shift operation since the tag is pointing to the right.
<lang perl6>my $n = 1024*2;
say $n while ($n +>= 1) != 0;</lang>
Here is a solution without the restraints:
<lang perl6>say 1024 +> $_ for 0..10;</lang>
And here's how you'd really write it, using a sequence operator that intuits the division for you:
<lang perl6>for 1024, 512, 256 ... 1 { .say }</lang>
PHP
<lang php>$i = 1024; while ($i > 0) {
echo "$i\n"; $i >>= 1;
}</lang>
PicoLisp
<lang PicoLisp>(let N 1024
(while (gt0 N) (println N) (setq N (/ N 2)) ) )</lang>
Pike
<lang pike>int main(){
int i = 1024; while(i > 0){ write(i + "\n"); i = i / 2; }
}</lang>
PL/I
<lang PL/I> declare i fixed binary initial (1024);
do while (i>0);
put skip list (i); i = i / 2;
end; </lang>
Pop11
<lang pop11>lvars i = 1024; while i > 0 do
printf(i, '%p\n'); i div 2 -> i;
endwhile;</lang>
PostScript
PostScript has no real while
loop, but it can easily be created with an endless loop and a check at the beginning:
<lang postscript>1024
{
dup 0 le % check whether still greater than 0 { pop exit } % if not, exit the loop if dup = % print the number 2 idiv % divide by two
} loop</lang>
PowerShell
<lang powershell>[int]$i = 1024 while ($i -gt 0) {
$i $i /= 2
}</lang>
Prolog
<lang prolog>while(0) :- !. while(X) :- X>0,write(X), nl, X1 is X // 2, while(X1).</lang>
PureBasic
<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</lang>
Python
<lang python>n = 1024 while n > 0:
print n n //= 2</lang>
R
<lang R>i <- 1024L while(i > 0) {
print(i) i <- i %/% 2
}</lang>
REBOL
<lang REBOL>REBOL [ Title: "Loop/While" Author: oofoe Date: 2009-12-19 URL: http://rosettacode.org/wiki/Loop/While ]
value: 1024 while [value > 0][ print value value: to-integer value / 2 ]</lang>
Retro
<lang Retro>1024 [ cr &putn sip 2 / dup ] while</lang>
REXX
version 1
Using integer division % here: <lang rexx>/*REXX program to show a DO WHILE construct. */ j=1024
do while j>0 say j j=j%2 end</lang>
output
1024 512 256 128 64 32 16 8 4 2 1
version 2
<lang rexx>/*REXX program to show a DO WHILE construct. */ x=1024
do while x>0 say right(x,10) x=x%2 /*in REXX, % is integer division. */ end</lang>
output
1024 512 256 128 64 32 16 8 4 2 1
Ruby
<lang ruby>i = 1024 while i > 0 do
puts i i /= 2
end</lang> The above can be written in one statement (using the return value of the Kernel#puts method: nil is false), but the readability suffers: <lang ruby>i = 1024 puts i or i /= 2 while i > 0</lang>
until condition
is equivalent to while not condition
.
<lang ruby>i = 1024 until i <= 0 do
puts i i /= 2
end</lang>
SAS
<lang sas>data _null_; n=1024; do while(n>0);
put n; n=int(n/2);
end; run;</lang>
Sather
<lang sather>class MAIN is
main is i ::= 1024; loop while!(i > 0); #OUT + i + "\n"; i := i / 2; end; end;
end;</lang>
Scala
<lang scala>var i = 1024 while (i > 0) {
println(i) i /= 2
}</lang>
Scheme
<lang scheme>(do ((n 1024 (quotient n 2)))
((<= n 0)) (display n) (newline))</lang>
Seed7
<lang seed7>$ include "seed7_05.s7i";
const proc: main is func
local var integer: i is 1024; begin while i > 0 do writeln(i); i := i div 2 end while; end func;</lang>
Slate
<lang slate>
- n := 1024.
[n isPositive] whileTrue:
[inform: number printString. n := n // 2]
</lang>
Smalltalk
<lang smalltalk>number := 1024. [ number > 0 ] whileTrue:
[ Transcript print: number; nl. number := number // 2 ]</lang>
Standard ML
<lang sml>val n = ref 1024; while !n > 0 do (
print (Int.toString (!n) ^ "\n"); n := !n div 2
)</lang>
But it is more common to write it in a tail-recursive functional style: <lang sml>let
fun loop n = if n > 0 then ( print (Int.toString n ^ "\n"); loop (n div 2) ) else ()
in
loop 1024
end</lang>
Suneido
<lang Suneido>i = 1024 while (i > 0)
{ Print(i) i = (i / 2).Floor() }</lang>
Output: <lang Suneido>1024 512 256 128 64 32 16 8 4 2 1</lang>
Tcl
<lang tcl>set i 1024 while {$i > 0} {
puts $i set i [expr {$i / 2}]
}</lang>
TI-89 BASIC
<lang ti89b>Local i 1024 → i While i > 0
Disp i intDiv(i, 2) → i
EndWhile</lang>
Trith
<lang trith>1024 [dup print 2 / floor] [dup 0 >] while drop</lang> <lang trith>1024 [dup print 1 shr] [dup 0 >] while drop</lang>
TUSCRIPT
<lang tuscript> $$ MODE TUSCRIPT i=1024 LOOP PRINT i i=i/2 IF (i==0) EXIT ENDLOOP </lang> Output:
1024 512 256 128 64 32 16 8 4 2 1
Unicon
See Icon.
UNIX Shell
<lang bash>x=1024 while $x -gt 0 ; do
echo $x x=$(( $x/2 ))
done</lang>
UnixPipes
<lang bash>(echo 1024>p.res;tail -f p.res) | while read a ; do
test $a -gt 0 && (expr $a / 2 >> p.res ; echo $a) || exit 0
done</lang>
Ursala
Unbounded iteration is expressed with the -> operator. An expression (p-> f) x, where p is a predicate and f is a function, evaluates to x, f(x), or f(f(x)), etc. as far as necessary to falsify p.
Printing an intermediate result on each iteration is a bigger problem because side effects are awkward. Instead, the function g in this example iteratively constructs a list of results, which is displayed on termination.
The argument to g is the unit list <1024>. The predicate p is ~&h, the function that tests whether the head of a list is non-null (equivalent to non-zero). The iterated function f is that which conses the truncated half of the head of its argument with a copy of the whole argument. The main program takes care of list reversal and formatting. <lang Ursala>#import nat
g = ~&h-> ^C/half@h ~&
- show+
main = %nP*=tx g <1024></lang> output:
1024 512 256 128 64 32 16 8 4 2 1
Explicit iteration has its uses but there are always alternatives. The same output is produced by the following main program using bit manipulation. <lang Ursala>main = %nP*=tK33 1024</lang>
V
<lang v>1024 [0 >] [
dup puts 2 / >int
] while</lang>
Vedit macro language
<lang vedit>#1 = 1024 while (#1 > 0) {
Num_Type(#1) #1 /= 2
}</lang> or with for loop: <lang vedit>for (#1 = 1024; #1 > 0; #1 /= 2) {
Num_Type(#1)
}</lang>
Visual Basic .NET
<lang vbnet>Dim x = 1024 Do
Console.WriteLine(x) x = x \ 2
Loop While x > 0</lang>
- Programming Tasks
- Iteration
- 6502 Assembly
- ActionScript
- Ada
- ALGOL 68
- AmigaE
- AppleScript
- AutoHotkey
- AWK
- BASIC
- Befunge
- Brat
- C
- C++
- C sharp
- Clojure
- ColdFusion
- Common Lisp
- D
- Delphi
- DWScript
- E
- Euphoria
- Factor
- FALSE
- Fantom
- Forth
- Fortran
- GML
- Go
- Groovy
- Haskell
- Icon
- Unicon
- Inform 7
- J
- Java
- JavaScript
- Joy
- LabVIEW
- Liberty BASIC
- Lisaac
- Logo
- Lua
- Mathematica
- MATLAB
- Octave
- Maxima
- MAXScript
- Make
- Metafont
- MIRC Scripting Language
- Modula-2
- Modula-3
- MOO
- NetRexx
- Nimrod
- Nemerle
- Oberon-2
- Objeck
- OCaml
- Oz
- PARI/GP
- Pascal
- Perl
- Perl 6
- PHP
- PicoLisp
- Pike
- PL/I
- Pop11
- PostScript
- PowerShell
- Prolog
- PureBasic
- Python
- R
- REBOL
- Retro
- REXX
- Ruby
- SAS
- Sather
- Scala
- Scheme
- Seed7
- Slate
- Smalltalk
- Standard ML
- Suneido
- Tcl
- TI-89 BASIC
- Trith
- TUSCRIPT
- UNIX Shell
- UnixPipes
- Ursala
- V
- Vedit macro language
- Visual Basic .NET
- GUISS/Omit
- Conditional loops