Integer sequence: Difference between revisions
(Convert to normal task.) |
(Give it a little more meat, for descriptive purposes.) |
||
Line 1: | Line 1: | ||
{{task}}Create a program that, when run, would display all integers from 1 to ∞ (or any relevant implementation limit), in sequence (i.e. 1, 2, 3, 4, etc) if given enough time. |
{{task}}Create a program that, when run, would display all integers from 1 to ∞ (or any relevant implementation limit), in sequence (i.e. 1, 2, 3, 4, etc) if given enough time. |
||
An example may not be able to reach arbitrarily-large numbers based on implementations limits. For example, if integers are represented as a 32-bit unsigned value with 0 as the smallest representable value, the largest representable value would be 4,294,967,295. Some languages support arbitrarily-large numbers as a built-in feature, while others make use of a module or library. |
|||
If appropriate, provide an example which reflect the language implementation's common built-in limits as well as an example which supports arbitrarily large numbers, and describe the nature of such limitations—or lack thereof. |
|||
=={{header|Ada}}== |
=={{header|Ada}}== |
Revision as of 01:34, 17 February 2011
You are encouraged to solve this task according to the task description, using any language you may know.
Create a program that, when run, would display all integers from 1 to ∞ (or any relevant implementation limit), in sequence (i.e. 1, 2, 3, 4, etc) if given enough time.
An example may not be able to reach arbitrarily-large numbers based on implementations limits. For example, if integers are represented as a 32-bit unsigned value with 0 as the smallest representable value, the largest representable value would be 4,294,967,295. Some languages support arbitrarily-large numbers as a built-in feature, while others make use of a module or library.
If appropriate, provide an example which reflect the language implementation's common built-in limits as well as an example which supports arbitrarily large numbers, and describe the nature of such limitations—or lack thereof.
Ada
<lang Ada>with Ada.Text_IO; procedure Integers is
Value : Integer := 1;
begin
loop Ada.Text_IO.Put_Line (Integer'Image (Value)); Value := Value + 1; end loop;
end Integers;</lang> alternative (iterating through all values of Positive (positive part of Integer) without endless loop): <lang Ada>with Ada.Text_IO; procedure Positives is begin
for Value in Positive'Range loop Ada.Text_IO.Put_Line (Positive'Image (Value)); end loop;
end Positives;</lang>
BASIC
<lang basic>5 LET A = 0 10 LET A = A + 1 20 PRINT A 30 GOTO 10</lang>
C
<lang c>#include <stdio.h>
- include <stdint.h>
int main() {
uint32_t i = 0; while (1) { printf("%u\n", ++i); }
return 0;
}</lang>
Alternatively: <lang c>#include <stdio.h>
- include <stdint.h>
int main() {
for (uint32_t i = 1; 1; i++) printf("%u\n", i);
return 0;
}</lang>
C#
<lang csharp>using System; using System.Numerics;
class Program {
static void Main() { BigInteger i = 1; while (true) { Console.WriteLine(i++); } }
}</lang>
C++
<lang cpp>#include <iostream>
- include <cstdint>
int main() {
uint32_t i = 0; while(true) std::cout << ++i << std::endl;
return 0;
}</lang>
Common Lisp
<lang lisp>(loop for i from 1 do (print i))</lang>
D
<lang d>import std.stdio, std.traits, std.bigint, std.string ;
void integerSequence(T)() if(is(T == BigInt) || isIntegral!T ) {
static if(is(T == BigInt)) { BigInt now = BigInt(1) ; BigInt max = BigInt(0) ; } else { T now = 1 ; T max = T.max ; } do write(now, " ") ; while (now++ != max) ; writeln("\nDone!") ;
}
void main() {
string answer ; while(answer.length == 0) { writeln("Do you have time?") ; writeln(" 1. I'm in hurry.") ; writeln(" 2. I've some time.") ; writeln(" 3. I'm on vacation.") ; writeln(" 4. I'm unemployed...") ; write(" 0. I'm immortal!\nEnter 0-4 or q for quit > ") ; readf("%s\n", &answer) ; switch (answer.tolower) { case "1": return integerSequence!ubyte ; case "2": return integerSequence!short ; case "3": return integerSequence!uint ; case "4": return integerSequence!long ; case "0": return integerSequence!BigInt ; case "q": return writeln("Bye bye!") ; default: writeln("Pardon? try again...") ; answer = "" ; } }
}</lang>
E
<lang e>for i in int > 0 { println(i) }</lang>
F#
<lang fsharp>// lazy sequence of integers starting with i let rec integers i =
seq { yield i yield! integers (i+1) }
Seq.iter (printfn "%d") (integers 1)</lang>
Haskell
<lang haskell>mapM_ print [1..]</lang>
Or less imperatively:
<lang haskell>(putStr . unlines . map show) [1..]</lang>
Java
Long limit: <lang java>public class Count{
public static void main(String[] args){ for(long i = 1; ;i++) System.out.println(i); }
}</lang> "Forever": <lang java>import java.math.BigInteger;
public class Count{
public static void main(String[] args){ for(BigInteger i = BigInteger.ONE; ;i = i.add(BigInteger.ONE)) System.out.println(i); }
}</lang>
OCaml
with an imperative style: <lang ocaml>let () =
let i = ref 0 in while true do print_int !i; print_newline (); incr i; done</lang>
with a fonctional style: <lang ocaml>let () =
let rec aux i = print_int i; print_newline (); aux (succ i) in aux 0</lang>
Perl
<lang perl>my $i = 0; print ++$i, "\n" while 1;</lang>
Perl 6
<lang perl6>.say for 1..*</lang>
PicoLisp
<lang PicoLisp>(for (I 1 T (inc I))
(printsp I) )</lang>
PureBasic
<lang PureBasic>OpenConsole() Repeat
a.q+1 PrintN(Str(a))
ForEver</lang>
Python
<lang python>i=1 while i:
print(i) i += 1</lang>
Or, alternatively: <lang python>from itertools import count
for i in count():
print(i)</lang>
QBASIC
<lang qbasic>A = 0 DO: A = A + 1: PRINT A: LOOP 1</lang>
Tcl
<lang tcl>package require Tcl 8.5 while true {puts [incr i]}</lang>