Loops/Infinite: Difference between revisions
(Add Bash example) |
|||
Line 54: | Line 54: | ||
} |
} |
||
}</lang> |
}</lang> |
||
=={{header|Bash}}== |
|||
<lang bash>while true; do echo "SPAM"; done</lang> |
|||
<lang bash>until false; do echo "SPAM"; done</lang> |
|||
<lang bash>for ((;;)); do echo "SPAM"; done</lang> |
|||
=={{header|BASIC}}== |
=={{header|BASIC}}== |
Revision as of 18:17, 10 September 2010
You are encouraged to solve this task according to the task description, using any language you may know.
Specifically print out "SPAM" followed by a newline in an infinite loop.
4DOS Batch
<lang 4dos>@echo off do forever
echo SPAM
enddo</lang>
6502 Assembly
Specific OS/hardware routines for printing are left unimplemented. <lang 6502asm>InfiniteLoop LDX #0 PrintLoop: LDA MSG,x JSR PrintAccumulator ;routine not implemented INX CPX #5 BNE PrintLoop JMP InfiniteLoop
MSG .byte "SPAM", $0A</lang>
ActionScript
<lang actionscript>while (true) {
trace("SPAM");
}</lang>
Ada
<lang ada>loop
Put_Line("SPAM");
end loop;</lang>
ALGOL 68
<lang algol68>DO
printf($"SPAM"l$)
OD</lang> Or the classic "dynamic halt": <lang algol68>loop x:
printf($"SPAM"l$);
loop x</lang>
AmigaE
<lang amigae>PROC main()
LOOP WriteF('SPAM') ENDLOOP
ENDPROC</lang>
AutoHotkey
<lang autohotkey>Loop
MsgBox SPAM `n</lang>
AWK
<lang awk>BEGIN {
while(1) { print "SPAM" }
}</lang>
Bash
<lang bash>while true; do echo "SPAM"; done</lang> <lang bash>until false; do echo "SPAM"; done</lang> <lang bash>for ((;;)); do echo "SPAM"; done</lang>
BASIC
Old-fashioned syntax: <lang qbasic>while 1
print "SPAM"
wend</lang>
Standard BASIC: <lang qbasic>do
print "SPAM"
loop</lang>
Also <lang qbasic>for i = 1 to 10 step 0
print "SPAM"
next i</lang>
With classic (minimal) BASIC, the standard way to make an infinite loop would be:
10 PRINT "SPAM" 20 GOTO 10
Batch File
Using goto
:
<lang dos>@echo off
- loop
echo SPAM
goto loop</lang>
Another variant which uses Windows NT's for
statement:
<lang dos>for /l %%x in (1,0,2) do @echo SPAM</lang>
This essentially is a counted loop which starts at 1
, increments by 0
and stops when the counter reaches 2
.
Befunge
Because the 2-D code space is toroidal, all loops are infinite unless explicitly stopped with @. <lang befunge>55+"MAPS",,,,,</lang>
Brainf***
<lang bf>++++++++++[->++++++>++++++++>+<<<]>+++++> [+++.---.<.>---.+++>.<]</lang>
C
<lang c>while(1) puts("SPAM\n");</lang> or <lang c> for(;;) puts("SPAM\n");</lang> or <lang c>do { puts("SPAM\n"); } while(1);</lang>
C++
<lang cpp>while (true)
std::cout << "SPAM" << std::endl;</lang>
or <lang cpp>for (;;)
std::cout << "SPAM" << std::endl;</lang>
or <lang cpp>do
std::cout << "SPAM" << std::endl;
while (true);</lang>
C#
<lang csharp>while (true) {
Console.WriteLine("SPAM");
}</lang>
ColdFusion
This will result in a JRun Servlet Error and heap dump.
With tags: <lang cfm><cfloop condition = "true NEQ false">
SPAM
</cfloop></lang> With script: <lang cfm><cfscript>
while( true != false ) { writeOutput( "SPAM" ); }
</cfscript></lang>
Clojure
<lang lisp>(loop [] (println "SPAM") (recur))</lang>
Common Lisp
<lang lisp>(loop (write-line "SPAM"))</lang>
D
<lang d>while(true) writefln("SPAM") ;</lang> <lang d>for(;;) writefln("SPAM") ;</lang> <lang d>l: writefln("SPAM"); goto l;</lang>
E
<lang e>while (true) {
println("SPAM")
}</lang>
<lang e>def f() {
println("SPAM") f <- ()
} f <- ()</lang>
The difference between these is that in the second, other activities can be interleaved with the loop; in the first, no other processing will occur in this vat.
Erlang
<lang erlang>-module (main). -export ([main/1]).
main(Any) ->
io:fwrite("SPAM~n",[]), main(Any)</lang>
F#
<lang fsharp> while true do
printfn "SPAM"
done
let rec forever () : unit =
printfn "SPAM" ; forever ()
</lang>
Factor
<lang factor>: spam ( -- ) "SPAM" print spam ;</lang> <lang factor>: spam ( -- ) [ "SPAM" print t ] loop ;</lang>
FALSE
<lang false>[1]["SPAM "]#</lang>
Forth
<lang forth>: email begin ." SPAM" cr again ;</lang>
Fortran
<lang fortran>DO
WRITE(*,*) "SPAM"
END DO</lang> Although deprecated GOTO is still available <lang fortran>10 WRITE(*,*) "SPAM"
GOTO 10</lang>
Go
<lang go>package main import "fmt" func main() { for { fmt.Printf("SPAM\n") } }</lang>
Groovy
<lang groovy>while (true) {
println 'SPAM'
}</lang>
Haskell
<lang haskell>forever (putStrLn "SPAM")</lang>
HicEst
<lang hicest>DO i = 1, 1E20 ! for i with 16 or more digits: i == i + 1 == loop infinite
WRITE() "SPAM"
ENDDO</lang>
Icon and Unicon
Icon
There are several ways to write infinite loops in Icon. The most straightforward would be with repeat.
<lang icon>procedure main()
repeat write("SPAM")
end</lang>
Alternately one could use one of these: <lang icon>until &fail do write("SPAM") # always fails, needs succeed to break ... while write("SPAM") # always succeeds, needs failure to break ... every write(|"SPAM") # generator always succeeds, needs failure to break ... while write(|"SPAM") # this is a common mistake that results in an endless loop ... while write(1 to 5) # a clearer version of the same mistake that generates endless 1's</lang>
Unicon
This Icon solution works in Unicon.
IDL
<lang IDL>while 1 do print,'SPAM'</lang>
Io
<lang io>loop("SPAM" println)</lang>
J
<lang j>-@:(][ 1!:2&2@('SPAM'"_)) (^:_) 1</lang>
Alternatively,
<lang j>smoutput bind 'SPAM'^:1e99 </lang>
This second implementation relies on numeric inaccuracies in IEEE floating point notation. For example, 1+1e98 is exactly equal to 1e98. That said, 1e99 iterations would still be significantly longer than the practical life of any machine anyone would care to dedicate to this task.
Java
<lang java>while(true){
System.out.println("SPAM");
}</lang>
<lang java>for(;;){
System.out.println("SPAM");
}</lang>
JavaScript
<lang javascript>for (;;) print("SPAM"); while (true) print("SPAM");</lang>
Joy
<lang joy>DEFINE loop == [1] swap while.
["SPAM\n" putchars] loop.</lang>
Lisaac
The "lisaac" compiler apparently doesn't like infinite loops. Using a static slot (variable) seems to be the only way to get away with "Recursivity without end (call_slot)." error. <lang Lisaac>- i : INTEGER; i := 1; { i = 1 }.while_do {
"SPAM\n".print;
};</lang>
Logo
<lang logo>forever [print "SPAM]</lang>
Lua
<lang lua> while 1 do
print("SPAM")
end </lang>
M4
<lang M4>define(`spam',`SPAM spam') spam</lang>
Make
<lang make>spam:
@echo SPAM $(MAKE)</lang>
MAXScript
<lang maxscript>while true do print "SPAM\n"</lang>
Metafont
<lang metafont>forever: message "SPAM"; endfor end</lang>
Modula-3
<lang modula3>LOOP
IO.Put("SPAM\n");
END;</lang>
MOO
<lang moo>while (1)
player:tell("SPAM");
endwhile</lang>
MUMPS
<lang MUMPS>
FOR WRITE "SPAM",!
</lang>
Objeck
<lang objeck> while(true) {
"SPAM"->PrintLine();
}; </lang>
OCaml
<lang ocaml>while true do
print_endline "SPAM"
done</lang>
or
<lang ocaml>let rec inf_loop() =
print_endline "SPAM"; inf_loop()
in inf_loop()</lang>
Seen like this it looks like the "too much functional" danger when a "while" loop looks far simpler, but the functional loop may be useful to provide data to the next loop without using mutable variable.
Octave
<lang octave>while(1)
disp("SPAM")
endwhile</lang>
Oz
<lang oz>for do
{Show 'SPAM'}
end</lang>
Pascal
<lang pascal>while true do
writeln('SPAM');</lang>
Alternatively: <lang pascal>repeat
writeln('SPAM')
until false;</lang>
Perl
<lang perl>print "SPAM\n" while 1;</lang>
Perl 6
<lang perl6>loop {
say 'SPAM';
}</lang> In addition, there are various ways of writing lazy, infinite lists in Perl 6: <lang perl6>print "SPAM\n" xx *; # repetition operator print "SPAM\n", ~* ... *; # series operator map {say "SPAM"}, ^Inf; # upto operator<lang>
PHP
<lang php>while(1)
echo "SPAM\n";</lang>
PicoLisp
<lang PicoLisp>(loop (prinl "SPAM"))</lang>
Pike
<lang pike>int main(){
while(1) write("SPAM\n");
}</lang>
PL/I
<lang PL/I> do forever;
put list ('SPAM'); put skip;
end; </lang>
Pop11
<lang pop11>while true do
printf('SPAM', '%p\n');
endwhile;</lang>
PostScript
<lang postscript>{}loop</lang>
PowerShell
<lang powershell>for () {
"SPAM"
}</lang>
Prolog
<lang prolog>repeat, write('SPAM'), nl, fail.</lang>
PureBasic
Repeat/Forever
<lang PureBasic>Repeat
PrintN("SPAM")
ForEver</lang>
Goto
<lang PureBasic>PrintIt: PrintN("SPAM") Goto PrintIt</lang>
Python
<lang python>while 1:
print "SPAM"</lang>
Note: one can also use: "True" or any other non-false value. In Python the following values are false: 0, "" (empty string), (,) and {} and [] (empty tuples, dictionaries or lists), None (the special object), and the False object. Any non-empty collection or string or non-zero numeric value is considered "True". However, according to Python Wiki, for Python versions 2.3+ this variant is optimized by the interpreter and thus is the fastest.
R
Note that the default R Gui buffers outputs before pushing them to the screen. To see this run either run in terminal mode, right click on the GUI window and deselect "Buffered Output" prior to execution, or add a call to flush.console() in the loop.
<lang R>repeat print("SPAM")</lang>
REBOL
<lang REBOL>forever [print "SPAM"]</lang>
REXX
<lang rexx>do forever
say "SPAM"
end</lang>
Ruby
<lang ruby>loop do
puts "SPAM"
end</lang>
Sather
<lang sather>class MAIN is
main is loop #OUT + "Spam\n"; end; end;
end;</lang>
Scala
<lang scala>while (true)
println("SPAM")</lang>
Scheme
<lang scheme>(do ()
(#f) (display "SPAM") (newline))</lang>
Slate
<lang slate>[inform: 'SPAM'] loop</lang>
Smalltalk
<lang smalltalk>[ true ] whileTrue: [ 'SPAM' displayNl ]</lang>
SNOBOL4
<lang snobol>loop output = "SPAM" :(loop) end</lang>
SNUSP
<lang snusp>@\>@\>@\>@\>++++++++++===!/ < < < < \
| | | \M=@@@@+@+++++# \.>.>.>.>./ | | \A=@@+@@@@+++# | \P=@@+@@+@@+++# \S=@@+@+@@@+++#</lang>
Standard ML
<lang sml>while true do
print "SPAM\n";</lang>
or
<lang sml>let
fun inf_loop () = ( print "SPAM\n"; inf_loop () )
in
inf_loop ()
end</lang>
Seen like this it looks like the "too much functional" danger when a "while" loop looks far simpler, but the functional loop may be useful to provide data to the next loop without using mutable variable.
SystemVerilog
<lang SystemVerilog>program main;
initial forever $display("SPAM");
endprogram </lang>
Transact-SQL
<lang sql>WHILE 1=1 BEGIN
PRINT "SPAM"
END</lang>
Tcl
<lang tcl>while true {
puts SPAM
}
- or
for {} 1 {} {
puts SPAM
}</lang>
TI-83 BASIC
There are a few ways to achieve this in TI-83 BASIC
<lang ti83b>
:Goto 1 :Lbl 1 :Disp "SPAM" :Goto 1
</lang>
Another way is by using a While loop
<lang ti83b>
:1→A :While A = 1 :Disp "SPAM"
</lang>
TI-89 BASIC
<lang ti89b>Loop
Disp "SPAM"
EndLoop</lang>
Trith
<lang trith>["SPAM" print] loop</lang>
UNIX Shell
<lang bash>while :; do echo SPAM; done</lang>
UnixPipes
<lang bash> yes SPAM</lang>
Unlambda
<lang unlambda> ``ci``s``s`kr``s``s``s``s`k.S`k.P`k.A`k.Mii</lang>
V
<lang v>true [
'SPAM' puts
] while</lang>
Vedit macro language
<lang vedit>while (1) {
Message("Spam\n")
}</lang> or: <lang vedit>do {
Message("Spam\n")
} while (1)</lang> or: <lang vedit>for (;1;) {
Message("Spam\n")
}</lang> "Nearly infinite" loop can be done by using constant ALL (=1073741824) as repeat count: <lang vedit>Repeat (ALL) {
Message("Spam\n")
}</lang>
Visual Basic
<lang vb>Do
Debug.Print("SPAM")
Loop</lang>
Visual Basic .NET
Platform: .NET
<lang vbnet>Do
Console.WriteLine("SPAM")
Loop</lang>
- Programming Tasks
- Iteration
- 4DOS Batch
- 6502 Assembly
- ActionScript
- Ada
- ALGOL 68
- AmigaE
- AutoHotkey
- AWK
- Bash
- BASIC
- Batch File
- Befunge
- Brainf***
- C
- C++
- C sharp
- ColdFusion
- Clojure
- Common Lisp
- D
- E
- Erlang
- F Sharp
- Factor
- FALSE
- Forth
- Fortran
- Go
- Groovy
- Haskell
- HicEst
- Icon
- Unicon
- IDL
- Io
- J
- Java
- JavaScript
- Joy
- Lisaac
- Logo
- Lua
- M4
- Make
- MAXScript
- Metafont
- Modula-3
- MOO
- MUMPS
- Objeck
- OCaml
- Octave
- Oz
- Pascal
- Perl
- Perl 6
- PHP
- PicoLisp
- Pike
- PL/I
- Pop11
- PostScript
- PowerShell
- Prolog
- PureBasic
- Python
- R
- REBOL
- REXX
- Ruby
- Sather
- Scala
- Scheme
- Slate
- Smalltalk
- SNOBOL4
- SNUSP
- Standard ML
- SystemVerilog
- Transact-SQL
- Tcl
- TI-83 BASIC
- TI-89 BASIC
- Trith
- UNIX Shell
- UnixPipes
- Unlambda
- V
- Vedit macro language
- Visual Basic
- Visual Basic .NET