Count in octal
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
package IIO is new Ada.Text_IO.Integer_IO(Integer);
begin
for I in 0 .. Integer'Last loop
IIO.Put(I, Base => 8);
Ada.Text_IO.New_Line;
end loop;
end Octal;</lang> First few lines of Output:
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#
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
<lang C>#include <stdio.h>
- include <limits.h>
int main() {
unsigned int i;
for (i = 0; i <= UINT_MAX; i++)
printf("%o\n", i);
return 0;
}</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>