Count in octal: Difference between revisions

Content added Content deleted

Inline

Revision as of 17:01, 18 March 2013

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.

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:

ALGOL 68

Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny.

<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$.

Works with: QBasic

<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.

Works with: Chipmunk Basic

<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>

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>

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>

Euphoria

<lang euphoria>integer i i = 0 while 1 do

   printf(1,"%o\n",i)
   i += 1

end while</lang>

Output:

Forth

Using INTS from Integer sequence#Forth <lang forth>: octal ( -- ) 8 base ! ; \ where unavailable

octal ints</lang>

Fortran

Works with: Fortran version 95 and later

<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:

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:

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:

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:

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>

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:

OCaml

<lang ocaml>let () =

 for i = 0 to max_int do
   Printf.printf "%o\n" i
 done</lang>

Output:

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:

Works with: PARI/GP version 2.4.3 and above

<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

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

<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>

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

(for ([i (in-naturals)])

 (displayln (number->string i 8)))

</lang>

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</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>

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 $2^{80}$ 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

Works with: bash

Works with: pdksh version 5.2.14

<lang sh>num=0 while test 0 -le $num; do

 printf '%o\n' $num
 num=$((num + 1))

done</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>

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:

@@ Line 1,116: / Line 1,116: @@
 =={{header|Whitespace}}==
-{{incorrect|Whitespace| -- <br>(no source), <br>(no output) <br> }}
 This program prints octal numbers until the internal representation of the current integer overflows to -1; it will never do so on some interpreters.