Count in octal: Difference between revisions
Second version added |
|||
Line 943:
=={{header|PL/I}}==
Version 1:
<lang PL/I>/* Do the actual counting in octal. */
count: procedure options (main);
declare v(5) fixed(1) static initial ((5)0);
Line 967:
end inc;
end count;</lang>
Version 2:
</lang>▼
<lang PL/I>count: procedure options (main); /* 12 Jan. 2014 */
declare (i, j) fixed binary;
do i = 0 upthru 2147483647;
do j = 30 to 0 by -3;
put edit (iand(isrl(i, j), 7) ) (f(1));
end;
put skip;
end;
end count;</lang>
Output:
<pre>
00000001173
00000001174
00000001175
00000001176
00000001177
00000001200
00000001201
00000001202
00000001203
00000001204
00000001205
00000001206
00000001207
00000001210
00000001211
00000001212
00000001213
00000001214
00000001215
00000001216
=={{header|PureBasic}}==
<lang PureBasic>Procedure.s octal(n.q)
|
Revision as of 14:12, 12 January 2014
You are encouraged to solve this task according to the task description, using any language you may know.
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 of the numeric type in use is reached.
- Integer sequence is a similar task without the use of octal numbers.
0815
<lang 0815>}:l:> Start loop, enqueue Z (initially 0).
}:o: Treat the queue as a stack and <:8:= accumulate the octal digits /=>&~ of the current number. ^:o:
<:0:- Get a sentinel negative 1. &>@ Enqueue it between the digits and the current number. { Dequeue the first octal digit.
}:p: ~%={+ Rotate each octal digit into place and print it. ^:p:
<:a:~$ Output a newline. <:1:x{+ Dequeue the current number and increment it.
^:l:</lang>
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#
Aime
<lang aime>integer o;
o = 0; do {
o_xinteger(8, o); o_byte('\n'); o += 1;
} while (0 < o);</lang>
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
AutoHotkey
<lang AHK>DllCall("AllocConsole") Octal(int){ While int out := Mod(int, 8) . out, int := int//8 return out } Loop { FileAppend, % Octal(A_Index) "`n", CONOUT$ Sleep 200 }</lang>
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 = 0; l <= 2147483647; l++) { printf("%o\n", l); }
}</lang>
BASIC
Some BASICs provide a built-in function to convert a number to octal, typically called OCT$
.
<lang qbasic>DIM n AS LONG FOR n = 0 TO &h7FFFFFFF
PRINT OCT$(n)
NEXT</lang>
However, many do not. For those BASICs, we need to write our own function.
<lang qbasic>WHILE ("" = INKEY$)
PRINT Octal$(n) n = n + 1
WEND END FUNCTION Octal$(what)
outp$ = "" w = what WHILE ABS(w) > 0 o = w AND 7 w = INT(w / 8) outp$ = STR$(o) + outp$ WEND Octal$ = outp$
END FUNCTION</lang>
See also: BBC BASIC, Liberty BASIC, PureBasic, Run BASIC
Applesoft BASIC
<lang ApplesoftBasic>10 N$ = "0"
100 O$ = N$ 110 PRINT O$ 120 N$ = "" 130 C = 1 140 FOR I = LEN(O$) TO 1 STEP -1 150 N = VAL(MID$(O$, I, 1)) + C 160 C = N >= 8 170 N$ = STR$(N - C * 8) + N$ 180 NEXT I 190 IF C THEN N$ = "1" + N$ 200 GOTO 100</lang>
BBC BASIC
Terminate by pressing ESCape. <lang bbcbasic> N% = 0
REPEAT PRINT FN_tobase(N%, 8, 0) N% += 1 UNTIL FALSE END REM Convert N% to string in base B% with minimum M% digits: DEF FN_tobase(N%, B%, M%) LOCAL D%, A$ REPEAT D% = N% MOD B% N% DIV= B% IF D%<0 D% += B% : N% -= 1 A$ = CHR$(48 + D% - 7*(D%>9)) + A$ M% -= 1 UNTIL (N%=FALSE OR N%=TRUE) AND M%<=0 =A$
</lang>
bc
<lang bc>obase = 8 /* Output base is octal. */ for (num = 0; 1; num++) num /* Loop forever, printing counter. */</lang>
The loop never stops at a maximum value, because bc uses arbitrary-precision integers.
Bracmat
Stops when the user presses Ctrl-C or when the stack overflows. The solution is not elegant, and so is octal counting. <lang bracmat>
( oct = . !arg:<8 & (!arg:~<0|ERROR) | str$(oct$(div$(!arg.8)) mod$(!arg.8)) )
& -1:?n & whl'(1+!n:?n&out$(!n oct$!n)); </lang>
Brainf***
<lang bf>+[ Start with n=1 to kick off the loop [>>++++++++<< Set up {n 0 8} for divmod magic [->+>- Then [>+>>]> do [+[-<+>]>+>>] the <<<<<<] magic >>>+ Increment n % 8 so that 0s don't break things >] Move into n / 8 and divmod that unless it's 0 -< Set up sentinel ‑1 then move into the first octal digit [++++++++ ++++++++ ++++++++ Add 47 to get it to ASCII
++++++++ ++++++++ +++++++. and print it
[<]<] Get to a 0; the cell to the left is the next octal digit >>[<+>-] Tape is {0 n}; make it {n 0} >[>+] Get to the ‑1 <[[-]<] Zero the tape for the next iteration ++++++++++. Print a newline [-]<+] Zero it then increment n and go again</lang>
C
<lang C>#include <stdio.h>
int main() {
unsigned int i = 0; do { printf("%o\n", i++); } while(i); return 0;
}</lang>
C#
<lang csharp>using System;
class Program {
static void Main() { var number = 0; do { Console.WriteLine(Convert.ToString(number, 8)); } while (++number > 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>
int main() {
unsigned i = 0; do { std::cout << std::oct << i << std::endl; ++i; } while(i != 0); return 0;
}</lang>
Clojure
<lang clojure>(doseq [i (range)] (println (format "%o" i)))</lang>
CoffeeScript
<lang coffeescript> n = 0
while true
console.log n.toString(8) n += 1
</lang>
Common Lisp
<lang lisp>(loop for i from 0 do (format t "~o~%" i))</lang>
Component Pascal
BlackBox Component Builder <lang oberon2> MODULE CountOctal; IMPORT StdLog,Strings;
PROCEDURE Do*; VAR i: INTEGER; resp: ARRAY 32 OF CHAR; BEGIN FOR i := 0 TO 1000 DO Strings.IntToStringForm(i,8,12,' ',TRUE,resp); StdLog.String(resp);StdLog.Ln END END Do; END CountOctal.
</lang>
Execute: ^Q CountOctal.Do
Output:
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
D
<lang d>import std.stdio;
void main() {
ubyte i; do writefln("%o", i++); while(i);
}</lang>
Dc
A simple infinite loop and octal output will do. <lang Dc>8o0[p1+lpx]dspx</lang>
Delphi
<lang Delphi>program CountingInOctal;
{$APPTYPE CONSOLE}
uses SysUtils;
function DecToOct(aValue: Integer): string; var
lRemainder: Integer;
begin
Result := ; repeat lRemainder := aValue mod 8; Result := IntToStr(lRemainder) + Result; aValue := aValue div 8; until aValue = 0;
end;
var
i: Integer;
begin
for i := 0 to 20 do WriteLn(DecToOct(i));
end.</lang>
Emacs Lisp
Displays in the message area interactively, or to standard output under -batch
.
<lang lisp>(dotimes (i most-positive-fixnum) ;; starting from 0
(message "%o" i))</lang>
Erlang
The fun is copied from Integer sequence#Erlang. I changed the display format. <lang Erlang> F = fun(FF, I) -> io:fwrite("~.8B~n", [I]), FF(FF, I + 1) end. </lang> Use like this:
F( F, 0 ).
Euphoria
<lang euphoria>integer i i = 0 while 1 do
printf(1,"%o\n",i) i += 1
end while</lang>
Output:
... 6326 6327 6330 6331 6332 6333 6334 6335 6336 6337
Forth
Using INTS from Integer sequence#Forth <lang forth>: octal ( -- ) 8 base ! ; \ where unavailable
octal ints</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>
Go
<lang go>package main
import (
"fmt" "math"
)
func main() {
for i := int8(0); ; i++ { fmt.Printf("%o\n", i) if i == math.MaxInt8 { break } }
}</lang> Output:
0 1 2 3 4 5 6 7 10 11 12 ... 175 176 177
Note that to use a different integer type, code must be changed in two places. Go has no way to query a type for its maximum value. Example: <lang go>func main() {
for i := uint16(0); ; i++ { // type specified here fmt.Printf("%o\n", i) if i == math.MaxUint16 { // maximum value for type specified here break } }
}</lang> Output:
... 177775 177776 177777
Note also that if floating point types are used for the counter, loss of precision will prevent the program from from ever reaching the maximum value. If you stretch interpretation of the task wording "maximum value" to mean "maximum value of contiguous integers" then the following will work: <lang go>import "fmt"
func main() {
for i := 0.; ; { fmt.Printf("%o\n", int64(i)) /* uncomment to produce example output if i == 3 { i = float64(1<<53 - 4) // skip to near the end fmt.Println("...") } */ next := i + 1 if next == i { break } i = next }
}</lang> Output, with skip uncommented:
0 1 2 3 ... 377777777777777775 377777777777777776 377777777777777777 400000000000000000
Big integers have no maximum value, but the Go runtime will panic when memory allocation fails. The deferred recover here allows the program to terminate silently should the program run until this happens. <lang go>import (
"big" "fmt"
)
func main() {
defer func() { recover() }() one := big.NewInt(1) for i := big.NewInt(0); ; i.Add(i, one) { fmt.Printf("%o\n", i) }
}</lang> Output:
0 1 2 3 4 5 6 7 10 11 12 13 14 ...
Groovy
Size-limited solution: <lang groovy>println 'decimal octal' for (def i = 0; i <= Integer.MAX_VALUE; i++) {
printf ('%7d %#5o\n', i, i)
}</lang>
Unbounded solution: <lang groovy>println 'decimal octal' for (def i = 0g; true; i += 1g) {
printf ('%7d %#5o\n', i, i)
}</lang>
Output:
decimal octal 0 00 1 01 2 02 3 03 4 04 5 05 6 06 7 07 8 010 9 011 10 012 11 013 12 014 13 015 14 016 15 017 16 020 17 021 ...
Haskell
<lang haskell>import Numeric
main = mapM_ (putStrLn . flip showOct "") [1..]</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>
J
Solution: <lang J> disp=.[:smoutput [:,@:(":"0) 8&#.^:_1
(>:[disp)^:_ ]0</lang>
The full result is not displayable, by design. This could be considered a bug, but is an essential part of this task. Here's how it starts:
<lang j> (>:[disp)^:_ ]0 0 1 2 3 4 5 6 7 10 11 ...</lang>
Java
<lang java>public class Count{
public static void main(String[] args){ for(int i = 0;i >= 0;i++){ System.out.println(Integer.toOctalString(i)); //optionally use "Integer.toString(i, 8)" } }
}</lang>
JavaScript
<lang javascript>for (var n = 0; n < 1e14; n++) { // arbitrary limit that's not too big
document.writeln(n.toString(8)); // not sure what's the best way to output it in JavaScript
}</lang>
LabVIEW
LabVIEW contains a Number to Octal String function. The following image shows the front panel and block diagram.
Lang5
<lang lang5>'%4o '__number_format set 0 do dup 1 compress . "\n" . 1 + loop</lang>
LFE
<lang lisp>(: lists foreach
(lambda (x) (: io format '"~p~n" (list (: erlang integer_to_list x 8)))) (: lists seq 0 2000))
</lang>
Liberty BASIC
Terminate these ( essentially, practically) infinite loops by hitting <CTRL<BRK> <lang lb>
'the method used here uses the base-conversion from RC Non-decimal radices/Convert 'to terminate hit <CTRL<BRK>
global alphanum$ alphanum$ ="01234567"
i =0
while 1 print toBase$( 8, i) i =i +1 wend
end
function toBase$( base, number) ' Convert decimal variable to number string. maxIntegerBitSize =len( str$( number)) toBase$ ="" for i =10 to 1 step -1 remainder =number mod base toBase$ =mid$( alphanum$, remainder +1, 1) +toBase$ number =int( number /base) if number <1 then exit for next i toBase$ =right$( " " +toBase$, 10) end function
</lang> As suggested in LOGO, it is easy to work on a string representation too. <lang lb>
op$ = "00000000000000000000"
L =len( op$)
while 1
started =0
for i =1 to L m$ =mid$( op$, i, 1) if started =0 and m$ ="0" then print " "; else print m$;: started =1 next i print
for i =L to 1 step -1 p$ =mid$( op$, i, 1) if p$ =" " then v =0 else v =val( p$) incDigit = v +carry if i =L then incDigit =incDigit +1 if incDigit >=8 then replDigit =incDigit -8 carry =1 else replDigit =incDigit carry =0 end if op$ =left$( op$, i -1) +chr$( 48 +replDigit) +right$( op$, L -i) next i
wend
end </lang> Or use a recursive listing of permutations with the exception that the first digit is not 0 (unless listing single-digit numbers). For each digit-place, list numbers with 0-7 in the next digit-place.
<lang lb> i = 0
while 1
call CountOctal 0, i, i > 0 i = i + 1
wend
sub CountOctal value, depth, startValue
value = value * 10 for i = startValue to 7 if depth > 0 then call CountOctal value + i, depth - 1, 0 else print value + i end if next i
end sub </lang>
Logo
No built-in octal-formatting, so it's probably more efficient to just manually increment a string than to increment a number and then convert the whole thing to octal every time we print. This also lets us keep counting as long as we have room for the string.
<lang logo>to increment_octal :n
ifelse [empty? :n] [ output 1 ] [ local "last make "last last :n local "butlast make "butlast butlast :n make "last sum :last 1 ifelse [:last < 8] [ output word :butlast :last ] [ output word (increment_octal :butlast) 0 ] ]
end
make "oct 0 while ["true] [
print :oct make "oct increment_octal :oct
]</lang>
LOLCODE
LOLCODE has no conception of octal numbers, but we can use string concatenation (SMOOSH) and basic arithmetic to accomplish the task. <lang LOLCODE>HAI 1.3
HOW IZ I octal YR num
I HAS A digit, I HAS A oct ITZ "" IM IN YR octalizer digit R MOD OF num AN 8 oct R SMOOSH digit oct MKAY num R QUOSHUNT OF num AN 8 NOT num, O RLY? YA RLY, FOUND YR oct OIC IM OUTTA YR octalizer
IF U SAY SO
IM IN YR printer UPPIN YR num
VISIBLE I IZ octal YR num MKAY
IM OUTTA YR printer
KTHXBYE</lang>
Lua
<lang lua>for l=1,2147483647 do
print(string.format("%o",l))
end</lang>
Mathematica
<lang Mathematica>x=0; While[True,Print[BaseForm[x,8];x++]</lang>
MATLAB / Octave
<lang Matlab> n = 0;
while (1) dec2base(n,8) n = n+1; end; </lang>
Or use printf: <lang Matlab> n = 0;
while (1) printf('%o\n',n); n = n+1; end; </lang>
If a predefined sequence should be displayed, one can use <lang Matlab> seq = 1:100;
dec2base(seq,8)</lang>
or <lang Matlab> printf('%o\n',seq);</lang>
Mercury
<lang>
- - module count_in_octal.
- - interface.
- - import_module io.
- - pred main(io::di, io::uo) is det.
- - implementation.
- - import_module int, list, string.
main(!IO) :-
count_in_octal(0, !IO).
- - pred count_in_octal(int::in, io::di, io::uo) is det.
count_in_octal(N, !IO) :-
io.format("%o\n", [i(N)], !IO), count_in_octal(N + 1, !IO).
</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>
NetRexx
<lang NetRexx>/* NetRexx */ options replace format comments java crossref symbols binary
import java.math.BigInteger
-- allow an option to change the output radix. parse arg radix . if radix.length() == 0 then radix = 8 k_ = BigInteger k_ = BigInteger.ZERO
loop forever
say k_.toString(int radix) k_ = k_.add(BigInteger.ONE) end
</lang>
NewLISP
<lang NewLISP>; file: ocount.lsp
- url
- http://rosettacode.org/wiki/Count_in_octal
- author
- oofoe 2012-01-29
- Although NewLISP itself uses a 64-bit integer representation, the
- format function relies on underlying C library's printf function,
- which can only handle a 32-bit octal number on this implementation.
(for (i 0 (pow 2 32)) (println (format "%o" i)))
(exit)</lang>
Sample output:
0 1 2 3 4 5 6 7 10 11 12 ...
OCaml
<lang ocaml>let () =
for i = 0 to max_int do Printf.printf "%o\n" i done</lang>
Output:
0 1 2 3 4 5 6 7 10 11 12 ... 7777777775 7777777776 7777777777
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>
Pascal
See Delphi
Perl
Since task says "system register", I take it to mean "no larger than machine native integer limit": <lang perl>use POSIX; printf "%o\n", $_ for (0 .. POSIX::UINT_MAX);</lang> Otherwise: <lang perl>use bigint; my $i = 0; printf "%o\n", $i++ while 1</lang>
Perl 6
<lang perl6>say .base(8) for ^Inf;</lang>
- Output:
0
Here we arbitrarily show as many lines of output as there are lines in the program. :-)
PHP
<lang php><?php for ($n = 0; is_int($n); $n++) {
echo decoct($n), "\n";
} ?></lang>
PicoLisp
<lang PicoLisp>(for (N 0 T (inc N))
(prinl (oct N)) )</lang>
PL/I
Version 1: <lang PL/I>/* Do the actual counting in octal. */ count: procedure options (main);
declare v(5) fixed(1) static initial ((5)0); declare (i, k) fixed;
do k = 1 to 999; call inc; put skip edit ( (v(i) do i = 1 to 5) ) (f(1)); end;
inc: proc;
declare (carry, i) fixed binary;
carry = 1; do i = 5 to 1 by -1; v(i) = v(i) + carry; if v(i) > 7 then do; v(i) = v(i) - 8; if i = 1 then stop; carry = 1; end; else carry = 0; end;
end inc;
end count;</lang> Version 2: <lang PL/I>count: procedure options (main); /* 12 Jan. 2014 */
declare (i, j) fixed binary;
do i = 0 upthru 2147483647; do j = 30 to 0 by -3; put edit (iand(isrl(i, j), 7) ) (f(1)); end; put skip; end;
end count;</lang> Output:
00000001173 00000001174 00000001175 00000001176 00000001177 00000001200 00000001201 00000001202 00000001203 00000001204 00000001205 00000001206 00000001207 00000001210 00000001211 00000001212 00000001213 00000001214 00000001215 00000001216
PureBasic
<lang PureBasic>Procedure.s octal(n.q)
Static Dim digits(20) Protected i, j, result.s For i = 0 To 20 digits(i) = n % 8 n / 8 If n < 1 For j = i To 0 Step -1 result + Str(digits(j)) Next Break EndIf Next ProcedureReturn result
EndProcedure
Define n.q If OpenConsole()
While n >= 0 PrintN(octal(n)) n + 1 Wend Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input() CloseConsole()
EndIf </lang> Sample output:
0 1 2 3 4 5 6 7 10 11 12 ... 777777777777777777767 777777777777777777770 777777777777777777771 777777777777777777772 777777777777777777773 777777777777777777774 777777777777777777775 777777777777777777776 777777777777777777777
Python
<lang Python>import sys for n in xrange(sys.maxint):
print oct(n)</lang>
Racket
<lang racket>
- lang racket
(for ([i (in-naturals)])
(displayln (number->string i 8)))
</lang> (Racket has bignums, so this loop will never end.)
Retro
Integers in Retro are signed.
<lang Retro>octal 17777777777 [ putn cr ] iter</lang>
REXX
If this REXX program wouldn't be stopped, it would count forever. <lang rexx>/*REXX program counts in octal until the number exceeds #pgm statements.*/
/*┌────────────────────────────────────────────────────────────────────┐
│ Count all the protons (and electrons!) in the universe. │ │ │ │ According to Sir Author Eddington in 1938 at his Tamer Lecture at │ │ Trinity Collecge (Cambridge), he postulated that there are exactly │ │ │ │ 136 ∙ 2^245 │ │ │ │ protons in the universe, and the same number of electrons, which │ │ is equal to around 1.57477e+79. │ │ │ │ [Although, a modern estimate is around 10^80.] │ └────────────────────────────────────────────────────────────────────┘*/
numeric digits 100000 /*handle almost all big numbers. */ numIn=right('number in', 20) /*used for indentation of output.*/ w=length(sourceline()) /*used for formatting width of #s*/
do #=0 to 136 * (2**256) /*Sir Eddington, here we come ! */ !=x2b( d2x(#) ) _=right(!, 3 * (length(_) % 3 + 1), 0) o= do k=1 to length(_) by 3 o=o'0'substr(_,k,3) end /*k*/
say numIn 'base ten = ' right(#,w) numIn "octal = " right(b2x(o)+0,w+w)
if #>sourceline() then leave /*stop if #protons > program statements.*/ end /*#*/ /*stick a fork in it, we're done.*/</lang>
output
number in base ten = 0 number in octal = 0 number in base ten = 1 number in octal = 1 number in base ten = 2 number in octal = 2 number in base ten = 3 number in octal = 3 number in base ten = 4 number in octal = 4 number in base ten = 5 number in octal = 5 number in base ten = 6 number in octal = 6 number in base ten = 7 number in octal = 7 number in base ten = 8 number in octal = 10 number in base ten = 9 number in octal = 11 number in base ten = 10 number in octal = 12 number in base ten = 11 number in octal = 13 number in base ten = 12 number in octal = 14 number in base ten = 13 number in octal = 15 number in base ten = 14 number in octal = 16 number in base ten = 15 number in octal = 17 number in base ten = 16 number in octal = 20 number in base ten = 17 number in octal = 21 number in base ten = 18 number in octal = 22 number in base ten = 19 number in octal = 23 number in base ten = 20 number in octal = 24 number in base ten = 21 number in octal = 25 number in base ten = 22 number in octal = 26 number in base ten = 23 number in octal = 27 number in base ten = 24 number in octal = 30 number in base ten = 25 number in octal = 31 number in base ten = 26 number in octal = 32 number in base ten = 27 number in octal = 33 number in base ten = 28 number in octal = 34 number in base ten = 29 number in octal = 35 number in base ten = 30 number in octal = 36 number in base ten = 31 number in octal = 37 number in base ten = 32 number in octal = 40 number in base ten = 33 number in octal = 41 number in base ten = 34 number in octal = 42 number in base ten = 35 number in octal = 43
Ruby
From the documentation: "A Fixnum holds Integer values that can be represented in a native machine word (minus 1 bit). If any operation on a Fixnum exceeds this range, the value is automatically converted to a Bignum."
<lang ruby>n = 0 loop do
puts "%o" % n n += 1
end
- or
for n in 0..Float::INFINITY
puts n.to_s(8)
end
- or
0.upto(1/0.0) do |n|
printf "%o\n", n
end</lang>
Run BASIC
<lang runbasic>input "Begin number:";b input " End number:";e
for i = b to e
print i;" ";toBase$(8,i)
next i end
function toBase$(base,base10) for i = 10 to 1 step -1
toBase$ = str$(base10 mod base) +toBase$ base10 = int(base10 / base) if base10 < 1 then exit for
next i end function</lang>
Rust
<lang Rust>// rust 0.9-pre
use std::uint;
fn main() {
for i in range(uint::min_value, uint::max_value) { println!("{:o}", i); }
}</lang> Please note: on x86_64 uint::max_value currently equals to 2^64-1 (or 18446744073709551615)
Salmon
Salmon has built-in unlimited-precision integer arithmetic, so these examples will all continue printing octal values indefinitely, limited only by the amount of memory available (it requires O(log(n)) bits to store an integer n, so if your computer has 1 GB of memory, it will count to a number with on the order of octal digits).
<lang Salmon>iterate (i; [0...+oo])
printf("%o%\n", i);;</lang>
or
<lang Salmon>for (i; 0; true)
printf("%o%\n", i);;</lang>
or
<lang Salmon>variable i := 0; while (true)
{ printf("%o%\n", i); ++i; };</lang>
Scala
<lang scala>0 until Int.MaxValue foreach(i=> println(i toOctalString))</lang>
Scheme
<lang scheme>(do ((i 0 (+ i 1))) (#f) (display (number->string i 8)) (newline))</lang>
Scratch
Seed7
<lang seed7>$ include "seed7_05.s7i";
const proc: main is func
local var integer: i is 0; begin repeat writeln(str(i, 8)); incr(i); until FALSE; end func;</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>
Using printf
Increment a decimal counter and use printf(1)
to print it in octal. Our loop stops when the counter overflows to negative.
<lang sh>#!/bin/sh num=0 while test 0 -le $num; do
printf '%o\n' $num num=`expr $num + 1`
done</lang>
Various recent shells have a bultin $(( ... ))
for arithmetic rather than running expr
, in which case
<lang sh>num=0 while test 0 -le $num; do
printf '%o\n' $num num=$((num + 1))
done</lang>
VBA
With i defined as an Integer, the loop will count to 77777 (32767 decimal). Error handling added to terminate nicely on integer overflow.
<lang VBA> Sub CountOctal() Dim i As Integer i = 0 On Error GoTo OctEnd Do
Debug.Print Oct(i) i = i + 1
Loop OctEnd: Debug.Print "Integer overflow - count terminated" End Sub </lang>
Whitespace
This program prints octal numbers until the internal representation of the current integer overflows to -1; it will never do so on some interpreters.
<lang Whitespace>
</lang>
It was generated from the following pseudo-Assembly.
<lang asm>push 0
- Increment indefinitely.
0:
push -1 ; Sentinel value so the printer knows when to stop. copy 1 call 1 push 10 ochr push 1 add jump 0
- Get the octal digits on the stack in reverse order.
1:
dup push 8 mod swap push 8 div push 0 copy 1 sub jn 1 pop
- Print them.
2:
dup jn 3 ; Stop at the sentinel. onum jump 2
3:
pop ret</lang>
XPL0
XPL0 doesn't have built-in routines to handle octal; instead it uses hex. <lang XPL0>include c:\cxpl\codes; \intrinsic code declarations
proc OctOut(N); \Output N in octal int N; int R; [R:= N&7; N:= N>>3; if N then OctOut(N); ChOut(0, R+^0); ];
int I; [I:= 0; repeat OctOut(I); CrLf(0);
I:= I+1;
until KeyHit or I=0; ]</lang>
Example output:
0 1 2 3 4 5 6 7 10 11 12 13 14 15 16 17 20 21
- Programming Tasks
- Solutions by Programming Task
- 0815
- Ada
- Aime
- ALGOL 68
- AutoHotkey
- AWK
- BASIC
- Applesoft BASIC
- BBC BASIC
- Bc
- Bracmat
- Brainf***
- C
- C sharp
- C++
- Clojure
- CoffeeScript
- Common Lisp
- Component Pascal
- D
- Dc
- Delphi
- Emacs Lisp
- Erlang
- Euphoria
- Forth
- Fortran
- Go
- Groovy
- Haskell
- Icon
- Unicon
- J
- Java
- JavaScript
- LabVIEW
- Lang5
- LFE
- Liberty BASIC
- Logo
- LOLCODE
- Lua
- Mathematica
- MATLAB
- Octave
- Mercury
- Modula-2
- NetRexx
- NewLISP
- OCaml
- PARI/GP
- Pascal
- Perl
- Perl 6
- PHP
- PicoLisp
- PL/I
- PureBasic
- Python
- Racket
- Retro
- REXX
- Ruby
- Run BASIC
- Rust
- Salmon
- Scala
- Scheme
- Scratch
- Seed7
- Tcl
- UNIX Shell
- Basic language learning
- Radices
- Iteration
- VBA
- Whitespace
- XPL0