Count in octal: Difference between revisions
Added Ada code |
m Added Ada code |
||
Line 10: | Line 10: | ||
package IIO is new Ada.Text_IO.Integer_IO(Integer); |
package IIO is new Ada.Text_IO.Integer_IO(Integer); |
||
begin |
begin |
||
Ada.Text_IO.Put_Line("Enter X; I'll count from 0 to 2**X in octal"); |
Ada.Text_IO.Put_Line("Enter X; I'll count from 0 to 2**X -1 in octal"); |
||
IIO.Get(X); |
IIO.Get(X); |
||
for I in 0 .. 2**X -1 loop |
for I in 0 .. 2**X -1 loop |
||
Line 18: | Line 18: | ||
Output: |
Output: |
||
<pre>>./octal |
<pre>>./octal |
||
Enter X; I'll count from 0 to 2**X in octal |
Enter X; I'll count from 0 to 2**X -1 in octal |
||
5 |
5 |
||
8#0# 8#1# 8#2# 8#3# 8#4# 8#5# 8#6# 8#7# 8#10# 8#11# 8#12# 8#13# 8#14# 8#15# 8#16# 8#17# 8#20# 8#21# 8#22# 8#23# 8#24# 8#25# 8#26# 8#27# 8#30# 8#31# 8#32# 8#33# 8#34# 8#35# 8#36# 8#37#</pre> |
8#0# 8#1# 8#2# 8#3# 8#4# 8#5# 8#6# 8#7# 8#10# 8#11# 8#12# 8#13# 8#14# 8#15# 8#16# 8#17# 8#20# 8#21# 8#22# 8#23# 8#24# 8#25# 8#26# 8#27# 8#30# 8#31# 8#32# 8#33# 8#34# 8#35# 8#36# 8#37#</pre> |
Revision as of 11:47, 15 June 2011
The task is to produce a sequential count in octal, starting at zero, and using an increment of a one for each consecutive number. Each number should appear on a single line, and the program should count until terminated, or until the maximum value that can be held within the system registers is reached (for a 32 bit system using unsigned registers, this value is 37777777777 octal).
Ada
<lang Ada>with Ada.Text_IO;
procedure Octal is
X: Integer; package IIO is new Ada.Text_IO.Integer_IO(Integer);
begin
Ada.Text_IO.Put_Line("Enter X; I'll count from 0 to 2**X -1 in octal"); IIO.Get(X); for I in 0 .. 2**X -1 loop IIO.Put(I, Base => 8, Width => ((X+14)/3)); end loop;
end Octal;</lang> Output:
>./octal Enter X; I'll count from 0 to 2**X -1 in octal 5 8#0# 8#1# 8#2# 8#3# 8#4# 8#5# 8#6# 8#7# 8#10# 8#11# 8#12# 8#13# 8#14# 8#15# 8#16# 8#17# 8#20# 8#21# 8#22# 8#23# 8#24# 8#25# 8#26# 8#27# 8#30# 8#31# 8#32# 8#33# 8#34# 8#35# 8#36# 8#37#
ALGOL 68
<lang algol68>#!/usr/local/bin/a68g --script #
INT oct width = (bits width-1) OVER 3 + 1; main: (
FOR i TO 17 # max int # DO printf(($"8r"8r n(oct width)dl$, BIN i)) OD
)</lang> Output:
8r00000000001 8r00000000002 8r00000000003 8r00000000004 8r00000000005 8r00000000006 8r00000000007 8r00000000010 8r00000000011 8r00000000012 8r00000000013 8r00000000014 8r00000000015 8r00000000016 8r00000000017 8r00000000020 8r00000000021
AWK
The awk extraction and reporting language uses the underlying C library to provide support for the printf command. This enables us to use that function to output the counter value as octal:
<lang awk>BEGIN {
for (l = 1; l < 2147483647; l++) { printf("%o\n", l); }
}</lang>
C++
This prevents an infinite loop by counting until the counter overflows and produces a 0 again. This could also be done with a for or while loop, but you'd have to print 0 (or the last number) outside the loop.
<lang cpp>#include <iostream>
- include <iomanip>
using namespace std;
int main() {
unsigned i = 0; do { cout << setbase(8) << i << endl; ++i; } while(i != 0);
}</lang>
Fortran
<lang fortran>program Octal
implicit none integer, parameter :: i64 = selected_int_kind(18) integer(i64) :: n = 0
! Will stop when n overflows from ! 9223372036854775807 to -92233720368547758078 (1000000000000000000000 octal)
do while(n >= 0) write(*, "(o0)") n n = n + 1 end do
end program</lang>
Icon and Unicon
<lang unicon>link convert # To get exbase10 method
procedure main()
limit := 8r37777777777 every write(exbase10(seq(0)\limit, 8))
end</lang>
Java
<lang java>public class Count{
public static void main(String[] args){ for(int i = 0;i <= Integer.MAX_VALUE;i++){ System.out.println(Integer.toOctalString(i)); //optionally use "Integer.toString(i, 8)" } }
}</lang>
Lua
<lang lua>for l=1,2147483647 do
print(string.format("%o",l))
end</lang>
Modula-2
<lang modula2>MODULE octal;
IMPORT InOut;
VAR num : CARDINAL;
BEGIN
num := 0; REPEAT InOut.WriteOct (num, 12); InOut.WriteLn; INC (num) UNTIL num = 0
END octal.</lang>
PARI/GP
Both versions will count essentially forever; the universe will succumb to proton decay long before the counter rolls over even in the 32-bit version.
Manual: <lang parigp>oct(n)=n=binary(n);if(#n%3,n=concat([[0,0],[0]][#n%3],n));forstep(i=1,#n,3,print1(4*n[i]+2*n[i+1]+n[i+2]));print; n=0;while(1,oct(n);n++)</lang>
Automatic:
<lang parigp>n=0;while(1,printf("%o\n",n);n++)</lang>
Perl 6
<lang perl6>say .fmt: '%o' for 0 .. *;</lang>
PicoLisp
<lang PicoLisp>(for (N 0 T (inc N))
(prinl (oct N)) )</lang>
Python
<lang Python>import sys for n in xrange(sys.maxint):
print oct(n)</lang>
Tcl
<lang tcl>package require Tcl 8.5; # arbitrary precision integers; we can count until we run out of memory! while 1 {
puts [format "%llo" [incr counter]]
}</lang>
UNIX Shell
We use the bc calculator to increment our octal counter:
<lang sh>#!/bin/sh num=0 while true; do
echo $num num=`echo "obase=8;ibase=8;$num+1"|bc`
done</lang>