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

8r00000000021

</pre>

 

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

21%8

22%8

</pre>

 

=={{header|D}}==

 

ubyte i;

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

while(i);

 

=={{header|Dc}}==

A simple infinite loop and octal output will do.

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

for i := 0 to 20 do

WriteLn(DecToOct(i));

 

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

6337

</pre>

 

=={{header|Forth}}==

Using INTS from [[Integer sequence#Forth]]

 

 

=={{header|Fortran}}==

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

implicit none

n = n + 1

end do

 

=={{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}}==

 

 

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

 

procedure main()

limit := 8r37777777777

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

 

=={{header|J}}==

'''Solution:'''

 

 

0

1

10

11

 

=={{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|LabVIEW}}==

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|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|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|Modula-2}}==

 

IMPORT InOut;

INC (num)

UNTIL num = 0

 

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

12

...

</pre>

 

=={{header|OCaml}}==

 

for i = 0 to max_int do

Printf.printf "%o\n" i

 

<pre>

0

 

Manual:

 

Automatic:

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

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

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

Otherwise:

my $i = 0;

 

 

=={{header|PHP}}==

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

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

}

 

=={{header|PicoLisp}}==

 

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

count: procedure options (main);

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

end inc;

 

=={{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|Racket}}==

#lang racket

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

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

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

 

 

=={{header|REXX}}==

If this REXX program wouldn't be stopped, it would count ''forever''.

 

 

 

o=

do k=1 to length(_) by 3

end /*k*/

 

end /*#*/

number in base ten = 0 number in octal = 0

number in base ten = 1 number in octal = 1

number in base ten = 31 number in octal = 37

number in base ten = 32 number in octal = 40

</pre>

 

 

loop do

puts "%o" % n

 

# or

puts n.to_s(8)

end

0.upto(1/0.0) do |n|

printf "%o\n", n

 

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

input " End number:";e

if base10 < 1 then exit for

next i

 

=={{header|Rust}}==

 

=={{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|Scala}}==

 

=={{header|Scheme}}==

 

=={{header|Scratch}}==

[[File:ScratchCountInOctal.png]]

 

=={{header|Seed7}}==

const proc: main is func

begin

repeat

incr(i);

until FALSE;

 

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

 

 

 

 

 

It was generated from the following pseudo-Assembly.

 

; Increment indefinitely.

0:

3:

pop

 

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

21

</pre>