Count in octal: Difference between revisions

 

=={{header|0815}}==

}:o: Treat the queue as a stack and

<:8:= accumulate the octal digits

<:a:~$ Output a newline.

<:1:x{+ Dequeue the current number and increment it.

 

=={{header|360 Assembly}}==

The program uses one ASSIST macro (XPRNT) to keep the code as short as possible.

OCTAL CSECT

USING OCTAL,R13 base register

EM12 DC X'40',9X'20',X'2120' mask CL12 11num

YREGS

{{out}}

<pre style="height:20ex">

{{works with|https://skilldrick.github.io/easy6502/ Easy6502}}

Easy6502 can only output using a limited video memory or a hexdump. However the output is correct up to 2 octal digits.

define SRC_LO $00

define SRC_HI $01

ora temp ;put the bottom 3 bits of the original input back.

and #$7F ;clear bit 7.

 

{{out}}

=={{header|8080 Assembly}}==

This assumes the CP/M operating system. The count will terminate after the largest unsigned 16-bit value is reached.

;-------------------------------------------------------

; useful equates

lhld oldstk ; get CP/M's stack back

sphl ; restore it

;------------------------------------------------------

; Octal output routine

mov a,l ; test if hl = 0

ora h

pop h ; get unshifted hl back

push h

ret

;-------------------------------------------------------

;-------------------------------------------------------

shlr: ora a ; clear carry

rar ; bit 0 of MSB has shifted in

mov l,a

ret

;-------------------------------------------------------

;

end

{{out}}

Showing the last 10 lines of the output.

1777777

</pre>

 

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program countOctal64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

=={{header|Action!}}==

CHAR ARRAY a(6)

BYTE i=[0]

UNTIL i=0

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Count_in_octal.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

 

procedure Octal is

Ada.Text_IO.New_Line;

end loop;

First few lines of Output:

<pre> 8#0#

 

=={{header|Aime}}==

 

o = 0;

o_byte('\n');

o += 1;

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

 

INT oct width = (bits width-1) OVER 3 + 1;

printf(($"8r"8r n(oct width)dl$, BIN i))

OD

Output:

<pre>

8r00000000020

8r00000000021

</pre>

 

=={{header|ALGOL W}}==

Algol W has built-in hexadecimal and decimal output, this implements octal output.

string(12) r;

string(8) octDigits;

for c := cPos - 1 step -1 until 0 do writeon( r( c // 1 ) )

end while_r_lt_MAXINTEGER

{{out}}

<pre>

12

...

</pre>

 

=={{header|APL}}==

Works with [[Dyalog APL]]. 100,000 is just an arbitrarily large number I chose.

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program countoctal.s */

bx lr @return

 

=={{header|Arturo}}==

 

print ["number in base 10:" pad to :string i 2

 

{{out}}

 

=={{header|AutoHotkey}}==

Octal(int){

While int

FileAppend, % Octal(A_Index) "`n", CONOUT$

Sleep 200

 

=={{header|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:

 

for (l = 0; l <= 2147483647; l++) {

printf("%o\n", l);

}

 

=={{header|BASIC}}==

{{works with|QBasic}}

 

FOR n = 0 TO &h7FFFFFFF

PRINT OCT$(n)

 

However, many do not. For those BASICs, we need to write our own function.

 

PRINT Octal$(n)

n = n + 1

WEND

Octal$ = outp$

 

See also: [[#BBC BASIC|BBC BASIC]], [[#Liberty BASIC|Liberty BASIC]], [[#PureBasic|PureBasic]], [[#Run BASIC|Run BASIC]]

 

==={{header|Applesoft BASIC}}===

 

100 O$ = N$

180 NEXT I

190 IF C THEN N$ = "1" + N$

 

==={{header|BASIC256}}===

valor = 0

do

until valor = 0

end

 

 

==={{header|Commodore BASIC}}===

Commodore BASIC has a little quirk where numeric values converted to a string also include a leading space for the possible negative sign; this is why the <code>STR$</code> function is wrapped in a <code>RIGHT$</code> function.

 

20 gosub 70

30 print oc$

100 oc$=left$(str$(n),1)+right$(str$(r),1)+oc$

110 if q<>0 then t=q:goto 80

 

{{output}}

==={{header|Sinclair ZX81 BASIC}}===

The octal number is stored and manipulated as a string, meaning that even with only 1k of RAM the program shouldn't stop until the number gets to a couple of hundred digits long. I have <i>not</i> left it running long enough to find out exactly when it does run out of memory. The <code>SCROLL</code> statement is necessary: the ZX81 halts when the screen is full unless it is positively told to scroll instead.

20 SCROLL

30 PRINT N$

120 GOTO 50

130 LET N$="1"+N$

 

=={{header|Batch File}}==

@echo off

:: {CTRL + C} to exit the batch file

set /a todivide/=8

goto loop2

{{out}}

<pre>

=={{header|BBC BASIC}}==

Terminate by pressing ESCape.

REPEAT

PRINT FN_tobase(N%, 8, 0)

UNTIL (N%=FALSE OR N%=TRUE) AND M%<=0

=A$

 

=={{header|bc}}==

 

The loop never stops at a maximum value, because bc uses [[arbitrary-precision integers (included)|arbitrary-precision integers]].

=={{header|BCPL}}==

This will count up from 0 until the limit of the machine word.

 

let start() be

x := x + 1

$) repeatuntil x = 0

 

=={{header|Befunge}}==

This is almost identical to the [[Binary digits#Befunge|Binary digits]] sample, except for the change of base and the source coming from a loop rather than a single input.

 

=={{header|BQN}}==

 

Oct←8{⌽𝕗|⌊∘÷⟜𝕗⍟(↕1+·⌊𝕗⋆⁼1⌈⊢)}

 

=={{header|Bracmat}}==

Stops when the user presses Ctrl-C or when the stack overflows. The solution is not elegant, and so is octal counting.

( oct

=

& -1:?n

& whl'(1+!n:?n&out$(!n oct$!n));

 

=={{header|Brainf***}}==

 

[>>++++++++<< Set up {n 0 8} for divmod magic

[->+>- Then

<[[-]<] Zero the tape for the next iteration

++++++++++. Print a newline

 

=={{header|C}}==

 

int main()

do { printf("%o\n", i++); } while(i);

return 0;

 

=={{header|C sharp|C#}}==

 

class Program

} while (++number > 0);

}

 

=={{header|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.

 

 

int main()

} while(i != 0);

return 0;

 

=={{header|Clojure}}==

 

=={{header|COBOL}}==

{{trans|Delphi}}

{{works with|GNU Cobol|2.0}}

IDENTIFICATION DIVISION.

PROGRAM-ID. count-in-octal.

END-PERFORM

.

 

=={{header|CoffeeScript}}==

n = 0

 

console.log n.toString(8)

n += 1

 

=={{header|Common Lisp}}==

 

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE CountOctal;

IMPORT StdLog,Strings;

END CountOctal.

 

Execute: ^Q CountOctal.Do<br/>

Output:

 

=={{header|Cowgol}}==

 

typedef N is uint16;

n := n + 1;

if n == 0 then break; end if;

 

=={{header|Crystal}}==

# using unsigned 8 bit integer, range 0 to 255

 

{{out}}

 

=={{header|D}}==

import std.stdio;

 

do writefln("%o", i++);

while(i);

 

=={{header|Dc}}==

=== Named Macro ===

A simple infinite loop and octal output will do.

 

=== Anonymous Macro ===

Needs <code>r</code> (swap TOS and NOS):

Pushing/poping TOS to a named stack can be used instead of swaping:

 

=={{header|DCL}}==

$ loop:

$ write sys$output f$fao( "!OL", i )

$ i = i + 1

{{out}}

<pre>00000000000

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

for i := 0 to 20 do

WriteLn(DecToOct(i));

 

=={{header|EDSAC order code}}==

Uses 17-bit integers, maximum 2^16 - 1 (177777 octal). It would take the original EDSAC 18 or 19 hours to exhaust these, so there is not much point in extending to 35-bit integers.

[Count in octal, for Rosetta Code.

EDSAC program, Initial Orders 2.]

PF [acc = 0 on entry]

[end]

{{out}}

<pre>

 

=={{header|Elixir}}==

or

IO.puts Integer.to_string(n,8)

{n,n+1}

or

 

=={{header|Emacs Lisp}}==

Displays in the message area interactively, or to standard output under <code>-batch</code>.

 

 

=={{header|Erlang}}==

The fun is copied from [[Integer sequence#Erlang]]. I changed the display format.

F = fun(FF, I) -> io:fwrite("~.8B~n", [I]), FF(FF, I + 1) end.

Use like this:

<pre>

 

=={{header|Euphoria}}==

i = 0

while 1 do

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

i += 1

 

Output:

 

=={{header|F Sharp|F#}}==

printfn "%o" num

countInOctal (num + 1)

 

 

=={{header|Factor}}==

 

=={{header|Forth}}==

Using INTS from [[Integer sequence#Forth]]

 

 

=={{header|Fortran}}==

{{works with|Fortran|95 and later}}

implicit none

n = n + 1

end do

 

=={{header|FreeBASIC}}==

 

Dim ub As UByte = 0 ' only has a range of 0 to 255

Print

Print "Press any key to quit"

 

=={{header|Frink}}==

while true

{

println[i -> octal]

i = i + 1

 

=={{header|Futhark}}==

look like octal numbers when printed in decimal.

 

fun octal(x: int): int =

loop ((out,mult,x) = (0,1,x)) = while x > 0 do

fun main(n: int): [n]int =

map octal (iota n)

 

=={{header|FutureBasic}}==

 

defstr word

next

 

 

Output:

 

=={{header|Go}}==

 

import (

}

}

Output:

<pre>

</pre>

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:

for i := uint16(0); ; i++ { // type specified here

fmt.Printf("%o\n", i)

}

}

Output:

<pre>

</pre>

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:

 

func main() {

i = next

}

Output, with skip uncommented:

<pre>

</pre>

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.

"big"

"fmt"

fmt.Printf("%o\n", i)

}

Output:

<pre>

=={{header|Groovy}}==

Size-limited solution:

for (def i = 0; i <= Integer.MAX_VALUE; i++) {

printf ('%7d %#5o\n', i, i)

 

Unbounded solution:

for (def i = 0g; true; i += 1g) {

printf ('%7d %#5o\n', i, i)

 

Output:

 

=={{header|Haskell}}==

 

main :: IO ()

mapM_

(putStrLn . flip showOct "")

 

=={{header|Icon}} and {{header|Unicon}}==

 

procedure main()

limit := 8r37777777777

every write(exbase10(seq(0)\limit, 8))

 

=={{header|J}}==

'''Solution:'''

 

 

0

1

10

11

 

 

So then we define disp as a word which displays its argument in octal and returns its argument as its result (unchanged).

 

 

 

=={{header|Java}}==

public static void main(String[] args){

for(int i = 0;i >= 0;i++){

}

}

 

=={{header|JavaScript}}==

document.writeln(n.toString(8)); // not sure what's the best way to output it in JavaScript

 

=={{header|jq}}==

Here we use JSON strings of octal digits to represent octal numbers, and therefore there is no language-defined upper bound for the problem. We are careful therefore to select an algorithm that will continue indefinitely so long as there are sufficient physical resources. This is done by framing the problem so that we can use jq's `recurse(_)`.

def octals:

# input and output: array of octal digits in reverse order

[0] | recurse(octal_add1) | reverse | join("");

 

To print the octal strings without quotation marks, invoke jq with the -r command-line option.

 

=={{header|Julia}}==

for i in one(Int64):typemax(Int64)

print(oct(i), " ")

sleep(0.1)

end

I slowed the loop down with a <code>sleep</code> to make it possible to see the result without being swamped.

 

 

=={{header|Klingphix}}==

 

:octal "" >ps [dup 7 band tostr ps> chain >ps 8 / int] [dup abs 0 >] while ps> tonum bor ;

( 0 10 ) sequence @octal map pstack

 

{{out}}

<pre>((0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 12))</pre>

 

=={{header|Kotlin}}==

 

// counts up to 177 octal i.e. 127 decimal

fun main(args: Array<String>) {

(0..Byte.MAX_VALUE).forEach { println("%03o".format(it)) }

 

{{out}}

LabVIEW contains a Number to Octal String function. The following image shows the front panel and block diagram.<br/>

[[file:Count_in_octal.png]]

 

=={{header|Lang5}}==

 

=={{header|langur}}==

 

We use the :8x interpolation modifier to create a string in base 8 (may use base 2 to 36).

 

 

writeln $"10x\.i; == 8x\.i:8x;"

 

{{out}}

 

=={{header|LFE}}==

(lambda (x)

(: io format '"~p~n" (list (: erlang integer_to_list x 8))))

(: lists seq 0 2000))

 

=={{header|Liberty BASIC}}==

Terminate these ( essentially, practically) infinite loops by hitting <CTRL<BRK>

'the method used here uses the base-conversion from RC Non-decimal radices/Convert

'to terminate hit <CTRL<BRK>

toBase$ =right$( " " +toBase$, 10)

end function

As suggested in LOGO, it is easy to work on a string representation too.

op$ = "00000000000000000000"

L =len( op$)

 

end

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.

i = 0

while 1

next i

end sub

 

=={{header|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.

 

ifelse [empty? :n] [

output 1

print :oct

make "oct increment_octal :oct

 

=={{header|LOLCODE}}==

LOLCODE has no conception of octal numbers, but we can use string concatenation (<tt>SMOOSH</tt>) and basic arithmetic to accomplish the task.

 

HOW IZ I octal YR num

IM OUTTA YR printer

 

 

=={{header|Lua}}==

 

print(string.format("%o",l))

 

=={{header|M4}}==

 

`ifelse($#,0,``$0'',

`pushdef(`$1',$2)$4`'popdef(`$1')$0(`$1',eval($2+$3),$3,`$4')')')dnl

forever(`y',0,1, `eval(y,8)

 

=={{header|Maple}}==

octcount := proc (n)

seq(printf("%a \n", convert(i, octal)), i = 1 .. n);

end proc;

 

=={{header|MACRO-10}}==

title OCTAL - Count in octal.

subttl PDP-10 assembly (MACRO-10 on TOPS-20). KJX 2022.

 

end start

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

 

=={{header|MATLAB}} / {{header|Octave}}==

while (1)

dec2base(n,8)

n = n+1;

Or use printf:

while (1)

printf('%o\n',n);

n = n+1;

 

If a predefined sequence should be displayed, one can use

or

 

=={{header|Mercury}}==

:- module count_in_octal.

:- interface.

io.format("%o\n", [i(N)], !IO),

count_in_octal(N + 1, !IO).

 

=={{header|min}}==

{{works with|min|0.19.3}}

min has no support for octal or base conversion (it is a minimalistic language, after all) so we need to do that ourselves.

(dup 0 ==) (pop () 0 shorten)

(((8 mod) (8 div)) cleave) 'cons linrec

 

0 (dup octal succ)

 

=={{header|МК-61/52}}==

0 * 7 - x=0 21 ИП1 x#0 28 БП

02 ИП0 1 + П0 С/П БП 00 ИП0 lg

 

=={{header|Modula-2}}==

 

IMPORT InOut;

INC (num)

UNTIL num = 0

 

=={{header|Nanoquery}}==

{{trans|C}}

Even though all integers are arbitrary precision, the maximum value that can be represented as octal using the format function is 2^64 - 1. Once this value is reached, the program terminates.

while i < 2^64

println format("%o", i)

i += 1

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols binary

 

k_ = k_.add(BigInteger.ONE)

end

 

=={{header|NewLISP}}==

; url: http://rosettacode.org/wiki/Count_in_octal

; author: oofoe 2012-01-29

(for (i 0 (pow 2 32)) (println (format "%o" i)))

 

 

Sample output:

 

=={{header|Nim}}==

for i in 0 ..< int.high:

 

=={{header|Oberon-2}}==

{{works with|oo2c}}

MODULE CountInOctal;

IMPORT

END

END CountInOctal.

{{out}}

<pre>

=={{header|OCaml}}==

 

for i = 0 to max_int do

Printf.printf "%o\n" i

 

{{out}}

 

Manual:

 

Automatic:

{{works with|PARI/GP|2.4.3 and above}}

 

=={{header|Pascal}}==

old string incrementer for Turbo Pascal transformed, same as in http://rosettacode.org/wiki/Count_in_octal#Logo, about 100x times faster than Dephi-Version, with the abilty to used preformated strings leading zeroes.

Added a Bit fiddling Version IntToOctString, nearly as fast.

{$Mode Delphi}

{$Optimization ON}

writeln('IntToOctString ',T1:8:3);

end.

{{out}}

<pre> 1 1

IncStr 0.944 secs

IntToOctString 2.218 secs</pre>

 

=={{header|Perl}}==

Since task says "system register", I take it to mean "no larger than machine native integer limit":

Otherwise:

my $i = 0;

The above count in binary or decimal and convert to octal.

This actually counts in octal.

It will run forever or until the universe ends, whichever comes first.

 

$_ = 0;

 

=={{header|Phix}}==

<span style="color: #008080;">without</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">i</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>

<span style="color: #000000;">i</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>

See [[Integer_sequence#Phix]] for something that will run in a browser, obviously use "%o" instead of "%d" to

make it display octal numbers, or more accurately in that case, mpz_get_str(i,8). <!--(phixonline)-->

 

=={{header|PHP}}==

for ($n = 0; is_int($n); $n++) {

echo decoct($n), "\n";

}

 

=={{header|Picat}}==

 

 

gen(N),

println(to_oct_string(N)),

gen(I, J) :-

I2 is I + 1,

 

{{out}}

 

=={{header|PicoLisp}}==

 

=={{header|Pike}}==

int i=1;

while(true)

write("0%o\n", i++);

{{Out}}

<pre>

=={{header|PL/I}}==

Version 1:

count: procedure options (main);

declare v(5) fixed(1) static initial ((5)0);

end inc;

 

Version 2:

declare (i, j) fixed binary;

 

end;

 

 

{{out}}

00000001215

00000001216

</pre>

 

=={{header|PL/M}}==

BDOS: PROCEDURE( FN, ARG ); /* CP/M BDOS SYSTEM CALL */

DECLARE FN BYTE, ARG ADDRESS;

CALL PR$NL;

END;

 

=={{header|PowerShell}}==

While ( $True )

{

[Convert]::ToString( ++$i, 8 )

 

=={{header|Prolog}}==

octalize will keep producing and printing octal number, there is no limit.

 

 

octal([O]) :- o(O).

octal(X),

(maplist(write, X), nl)

 

=={{header|PureBasic}}==

Static Dim digits(20)

Protected i, j, result.s

CloseConsole()

EndIf

Sample output:

<pre>0

 

=={{header|Python}}==

for n in xrange(sys.maxint):

 

=={{header|Quackery}}==

 

=={{header|Racket}}==

#lang racket

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

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

(Racket has bignums, so this loop will never end.)

 

=={{header|Raku}}==

(formerly Perl 6)

{{out}}

<pre>0</pre>

 

The technique used is to convert the decimal number to binary, and separate the binary digits in groups of three, and then convert those binary groups (numbers) to decimal.

 

/*┌────────────────────────────────────────────────────────────────────┐

if #>sourceline() then leave /*stop if # of protons > pgm statements*/

end /*#*/

{{out|output}}

<pre style="height:38ex">

 

=={{header|Ring}}==

size = 30

for n = 1 to size

end

return output

 

=={{header|Ruby}}==

loop do

puts "%o" % n

0.step do |n|

puts format("%o", n)

 

=={{header|Run BASIC}}==

input " End number:";e

if base10 < 1 then exit for

next i

 

=={{header|Rust}}==

for i in 0..std::usize::MAX {

println!("{:o}", i);

}

 

=={{header|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 <math>2^{80}</math> octal digits).

 

 

or

 

 

or

 

while (true)

{

printf("%o%\n", i);

++i;

 

=={{header|S-BASIC}}==

Although many BASICs have a built-in OCT$ function, S-BASIC does not, so we have to supply our own

rem - return p mod q

function mod(p, q = integer) = integer

 

end

{{out}}

Showing first and last 10 lines of output

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

 

=={{header|Scratch}}==

[[File:ScratchCountInOctal.png]]

 

=={{header|Seed7}}==

This example uses the [http://seed7.sourceforge.net/libraries/integer.htm#%28in_integer%29radix%28in_integer%29 radix] operator to write a number in octal.

 

const proc: main is func

incr(i);

until FALSE;

 

=={{header|Sidef}}==

=={{header|Simula}}==

BEGIN

 

END;

END.

 

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

n printOn:Stdout radix:8.

Stdout cr.

{{out}}

<pre>1

 

=={{header|Sparkling}}==

printf("%o\n", i);

 

=={{header|Standard ML}}==

fun count n = (print (Int.fmt StringCvt.OCT n ^ "\n"); count (n+1))

in

val _ = count 0

 

=={{header|Swift}}==

 

func octalSuccessor(value: String) -> String {

println(n)

n = octalSuccessor(n)

 

{{Output}}

 

=={{header|Tcl}}==

while 1 {

puts [format "%llo" [incr counter]]

 

=={{header|UNIX Shell}}==

We use the bc calculator to increment our octal counter:

 

num=0

while true; do

echo $num

num=`echo "obase=8;ibase=8;$num+1"|bc`

 

===Using printf ===

Increment a decimal counter and use <code>printf(1)</code> to print it in octal. Our loop stops when the counter overflows to negative.

 

num=0

while test 0 -le $num; do

printf '%o\n' $num

num=`expr $num + 1`

 

Various recent shells have a bultin <code>$(( ... ))</code> for arithmetic rather than running <code>expr</code>, in which case

{{works with|bash}}

{{works with|pdksh|5.2.14}}

while test 0 -le $num; do

printf '%o\n' $num

num=$((num + 1))

 

=={{header|VBA}}==

With i defined as an Integer, the loop will count to 77777 (32767 decimal). Error handling added to terminate nicely on integer overflow.

 

Sub CountOctal()

Dim i As Integer

Debug.Print "Integer overflow - count terminated"

End Sub

 

=={{header|VBScript}}==

For i = 0 To 20

WScript.StdOut.WriteLine Oct(i)

Next

 

=={{header|Vim Script}}==

while counter >= 0

echon printf("%o\n", counter)

let counter += 1

 

fn main() {

for i := i8(0); ; i++ {

}

}

{{out}}

<pre>

=={{header|VTL-2}}==

Stops at 65535, the largest integer supported by VTL-2.

1010 #=2000

1020 ?=""

2090 E=E-1

2100 #=E>1*2080

{{out}}

<pre>

This program prints octal numbers until the internal representation of the current integer overflows to -1; it will never do so on some interpreters.

 

 

 

 

 

It was generated from the following pseudo-Assembly.

 

; Increment indefinitely.

0:

3:

pop

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var i = 0

System.print(Conv.oct(i))

i = i + 1

 

{{out}}

=={{header|XPL0}}==

XPL0 doesn't have built-in routines to handle octal; instead it uses hex.

 

proc OctOut(N); \Output N in octal

I:= I+1;

until KeyHit or I=0;

 

Example output:

 

=={{header|zig}}==

const fmt = std.fmt;

const warn = std.debug.warn;

warn("{}\n", buf);

}

 

=={{header|Z80 Assembly}}==

Outputs octal values 0 through 77 (decimal 0 to 63, or hexadecimal 0x00 to 0x3F.)

 

ld b,&40 ;how many numbers to print.

loop_showOctal:

add a,&F0

adc a,&40 ;this sequence of instructions converts hexadecimal values to ASCII.

 

{{out}}

 

=={{header|zkl}}==

{{out}}

<pre>

 

=={{header|ZX Spectrum Basic}}==

20 FOR i=0 TO 20

30 LET o$="": LET n=i

80 NEXT i

90 STOP