Print 0 to 100 without 1-9 characters

Question

Print integers 0 to 100 (inclusive) without using characters 123456789 in your code.

Separator of numbers can be comma or white space (by default <blank>, <horizontal tabulator>, <newline>, <carriage return>, <form feed> or <vertical tabulator>).

Shortest code wins.

Answer 1

SimpleTemplate 0.84, 45 bytes

This was fun, but quite difficult.

The code outputs all numbers from 0 to 100, with a trailing newline:

{@setC 0}{@for_ from"   "to"m"}{@echolC}{@incC}

Due to bugs in the compiler, the tab character (inside {@for_ from" "to"m"}) MUST be a real tab.

---

Ungolfed

This version should be easier to read, despite being functionally the same:

{@set counter 0}
{@for i from "  " to "m"}
    {@echo counter, EOL}
    {@inc counter}
{@/}

Closing the {@for [...]} is optional, but left here for the cleanest code possible.

---

You can try this on https://ideone.com/tLsDFn

Answer 2

Stax, 5 bytes

AJ^rJ

Run and debug it

AJ^   10 squared plus 1 (101)
   r  range from 0..n-1
    J join with spaces

Answer 3

Elixir, 42 28 bytes

(?b-?a)..?d|>Enum.join("\n")

Try it online!

Answer 4

Japt, 2 bytes

Lò

Try it online!

This outputs a list of numbers from 0 to 100 separated by commas.

How it works

Lò
L   -Number 100 
 ò  -Creates an inclusive range from 0 to L, and return it in the output

Answer 5

C++, 77 Bytes

#import<iostream>
main(){for(int i=0;i<=int('d');++i)  std::cout<<i<<" ";}

Here, I've used the ASCII value and ran the loop and printed the value. Simple!

Answer 6

TeX, 57 bytes

\newcount~\loop\advance~`^^A\the~ \ifnum~<`^^%\repeat\bye

Makes uses of these two tricks:

• \$\rm\TeX\$'s preprocessor runs through the code and replaces any instance of two consecutive superscript (category code 7) characters followed by a character token, and adds/subtracts 64 from its ascii code, hence ^^A becomes NUL.
• \$\rm\TeX\$ has a `backtick notation' of inputting numbers that reads the following character's ascii code instead.

Answer 7

GolfScript, 8/11 bytes

'e'{}/,`

Try it online! - 8 Bytes

Makes an array of values of e (101) elements, starting at 0, then formats with spaces. The format also has brackets at either end of the output, so it may not be valid. If not, they can be removed with 3 more bytes:

'e'{}/,' '*

Try it online! - 11 Bytes

Answer 8

V (vim), 30 bytes

i00<esc><C-a>hxpi0<esc>0"aDi0<esc>qqYp<C-a>q@a@qdd

Try it online!

can definitely be improved.

Answer 9

K (oK), 4 bytes

Solution:

!"e"

Try it online!

Explanation:

Scrolling through the other solutions tells me I wasn't as novel as I hoped when I came up with this.

!"e" / the solution
 "e" / ASCII 101
!    / til (i.e. range 0..n-1

Answer 10

Barrel, 9 bytes

#d(n+¶)n

Explanation:

#        // as many times as...
 d       // ...the ASCII value of 'd' (100)...
  (   )  // Create a single of instruction for the loop
   n     // print the accumulator of a number
    +    // increase the accumulator
     ¶   // print a newline
       n // print the final number

The final n is necessary because the loop only prints the numbers 0 to 99.

I could've shaved off 2 bytes by doing #e(n+¶, which would have used the ASCII value of 'e' (101) and also utilized the self-closing properties of the () instruction, but I had already assigned e to be the value of the mathematical constant \$e\$.

Answer 11

Pxem, 21 20 bytes (filename) + 0 bytes (content) = 23 21 20 bytes, requires unprintable character.

• Filename (escaped unprintable): \001.r.-.z.c.n,.o\001.+.ce.a
• Content: empty.

Try it online!

With comments

XX.z
# push 1; push int(rand()*pop)
## NOTE rand() outputs 0<=n<1
## NOTE assuming NUL cannot be used for filename
.a\001.rXX.z
# while size<2 || pop!=pop; do
.a.zXX.z
  # dup; print pop; push comma; putc pop
  .a.c.n,.oXX.z
  # push 1; push pop+pop; dup; push 101
  .a\001.+.ce
# done
.a.a

---

Pxem, 3 bytes (filename) + 20 bytes (content) = 23 bytes, requires unprintable character.

• Filename: e.e
• Content (some unprintables are escaped): .c.w\001.-.e.+.n .o.d.a

With comment

e.eXX.z # push 101; call content
.a

XX.z
# dup; while pop!=0; do
.a.c.wXX.z
  # push 1; push abs(pop-pop); call content (* result of final stack will be pushed to original *)
  .a\001.-.eXX.z
  # push pop+pop; print pop; push space; print pop; return
  .a.+.n .o.dXX.z
# done; (* implicit return *)
.a.a

Try it online! (with pxem.posixism)

Answer 12

///, 231 166 bytes

/\\\\\/\//\\\/\/\/\/\/\/\/\/\/\/\/\///\/\\\/\/\//\\\/\
\/\\\\\\\/\
\\\/\/\\\\\\\/\\\/\\\/\\\\\\\\\\\/\/\/\\\/\\\/\\\\\\\\\\\/\/\\\\\\\/\
\\\/\/\/\\\/\///\\\\\\\\\\\//

Try it online!

This was really fun to make. Sadly, there is a single newline. Using a backslash instead breaks everything, and I don't really want to figure out where everything is and fix it.

Update: I remade it from the ground up, it is now much smaller, and works with only slashes. Unfortunately, the challenge specifies commas and whitespace seperators only, so only slashes is not allowed.

Slashes only:

///, 182 bytes

/\\\\\/\//\\\/\/\/\/\/\/\/\/\/\/\/\///\/\\\/\/\//\\\/\\\\\/\\\\\\\/\\\\\\\\\\\/\/\\\\\\\/\\\/\\\/\\\\\\\\\\\/\/\/\\\/\\\/\\\\\\\\\\\/\/\\\\\\\/\\\\\\\\\\\/\/\/\\\/\//\\/\\\\\\\\\\\//

Try it online!

Answer 13

GFortran, 29 bytes

try it online!

print*,(j,j=0,ichar('d'))
end

Similar to this.

Answer 14

MathGolf, 4 bytes

♀)rn

Outputs with newline delimiter.

Try it online.

Explanation:

♀     # Push 100
 )    # Increment it to 101
  r   # Pop and push a list in the range [0,101)
   n  # Pop and join it by newlines
      # (after which the entire stack is output implicitly)

Answer 15

Python 3; 46 Bytes

x=True;a=x+x;b=a*a+x;print(*range(a*a*b*b+x))

Answer 16

ErrLess, 23 25 17 bytes

Thanks to Jo King for saving 8 bytes

0Z@#@'d<l+[.a?l-z

Explanation

0   { Add zero to the stack: (x) }
Z   { Set a "checkpoint" to jump back to later }
@#@ { Output as number & Duplicate: (x x) }
'd< { x < d - true -> -1; false -> 0? (x x<d) }
l   { Get the length of the top element (-1 for integers): (x x<d -1) }
+   { Add: (x [-2 or -1]) }
[   { Skip backwards that many instructions (skip forwards 1 or 2): (x) }
.   { Halt }
a?  { Push 10 and print (print newline) }
l-  { Increment: (x--1) }
z   { Go to "checkpoint" }

Try it online!

Answer 17

Go, 63 bytes

package main
func main(){for i:=' ';i<'';i++{println(i-' ')}}

Attempt This Online!

Upper bound for the loop has value 133 NEXT LINE (NEL). Separator is newlines. Prints to STDERR.

Answer 18

Kotlin, 48 46 bytes

('P'..'´').joinToString(","){""+it.minus('P')}

Saving two bytes by using other chars from the ascii table that only takes one instead of two bytes.

Try it online!

48 bytes version

('\n'..'n').joinToString(","){""+it.minus('\n')}

Using the ascii table to get those numbers.

Try it online!

---

When brackets are allowed at the start and end then this is smaller:

29 bytes

('P'..'´').map{it.minus('P')}

Try it online!

Answer 19

><>, 18 bytes

0::naoaa*(?!;ba-+!

Try it online!

Explanation

0                   Initialize stack with 0
 ::                 Duplicate the top of the stack twice, once for printing and once for comparing
   n                Pop the top of the stack, and print as a number
    ao              Push 0xa to the stack, and pop it to print as a char
      aa*           Push 100 (10*10) onto the stack
         (          Pop the top two values of the stack, and compare if one is less than the other
          ?!;       If not, halt execution, else...
             ba-    Push 1 (11-10) onto the stack
                +   Add the top two values on the stack
                 !  Skip the next instruction
                    IP Moves back to the 0

Answer 20

Pyth, 7 bytes

0S^ThhZ

Try it online!

Yay! First answer using an actual golfing languages. Since I’m new to Pyth, I’m assuming this can be optimized further :)

Edit: I misread the problem :/ so +1 byte. And guess what? Somebody made a 4 byte answer in pyth.

Explanation:

0         Zero
 S        In this case it makes a list from 1 to a number
  ^       Exponent of…
   T      Ten to the…
    hh    Increase the following number by two (one for each h)
     Z    Zero (now two after being increased)
          So basically push 0 then make a list from 1 to ten squared.

Answer 21

Knight, 37 36 29 21 bytes

-8 bytes thanks to @Razetime for reminding me about the ASCII function, which made my entire coercion thing useless

;O=a 0W>A'd'aO=a++0Ta

Try It Online!

Answer 22

GolfScript, 6 bytes

'e'),`

Try it online!

Similar to the other GolfScript answer, the output has brackets, which can be removed with the following 7-byte answer:

GolfScript, 7 bytes

'e'),n*

Try it online!

Answer 23

Thunno, \$ 4 \log_{256}(96) \approx \$ 3.29 bytes

'eOR

Attempt This Online!

Outputs [[0, 1, 2, ..., 99 100]].

Thunno j, \$ 6 \log_{256}(96) \approx \$ 4.94 bytes

'eORAJ

Attempt This Online!

Outputs 0 1 2 ... 99 100.

Explanation

'e      # Push 'e'
  O     # Get the ordinal, 101
        # (this is wrapped in a list)
   R    # Push range(0, 101)
        # (again wrapped in a list)

    AJ  # Get the first item of the list
        # j flag joins by spaces

Answer 24

Pyt, 7 bytes

00⁺⁺ᴇŘÁ

Try it online!

0           push 0
 0⁺⁺        push 0 and increment twice
    ᴇ       10^2
     Ř      push Řange (0,1,...,100)
      Á     push contents of Árray to stack; implicit print

Answer 25

Hebigo, 25 bytes

print: : :* range:ord:"e"

Answer 26

Ly, 9 5 3 bytes

'dR

Try it online!

Dropped 4 chars thanks for LyricLy(!)

Prints using LF as the delimiter by generating the list of 0-100 on the stack, then using a "print the whole stack" command.

 'd   - push 100 (codepoint for "d") on the stack
   R  - use "range" command to generate the list of numbers
      - the stack prints as numbers automatically

Answer 27

Backhand, 13 bytes

:_@v^O-
e]'}:

Try it online!

I don't feel like this is optimal, but I can't figure out how to do better than that.

The literal newline is just a command that prints a newline, so I replaced it with n so that the explanation is hopefully easier to follow.

The entire program is a single loop that mostly operates with step size 2 (to minimize unused spaces).

:_@v^O-ne]'}:   initial step size is 3
                stack contains the current loop counter `n`, or empty (implicit 0)
:               [n n] duplicate
   v            reduce step size to 2
     O          [n] output as number
       n        output literal newline
         ]      [n+1] increment
           }    bump the IP once to the right, so it can run
                different instructions on the way back
            :   [n+1 n+1] duplicate
        e '     [n+1 n+1 101] push 'e' = 101
      -         [n+1 n-100] subtract
    ^           increase step size to 3
 _              if the top is 0, bump to the right, otherwise bump to the left
  @             right: halt
                left: return to the beginning of the loop

Answer 28

Pascal, 94 B

This full program complies with ISO standards 7185 (“Standard Pascal”) and 10206 (“Extended Pascal”). The statement write(integerExpression) is automatically expanded to write(integerExpression:integerDefaultMinimumWidth). The value of integerDefaultMinimumWidth is implementation-defined. The following code requires that integerDefaultMinimumWidth ≥ 4 to ensure adequate number separation.

program p(output);var n:integer;begin n:=succ(succ(0));for n:=0 to sqr(n*n*n+n)do write(n)end.

70 B: Provided that the character 'd' has an (implementation-defined) ordinal value of 100 (like in ASCII) you can write:

program p(output);var c:char;begin for c:=''to'd'do write(ord(c))end.

Note, the first character literal '' is chr(0). It is assumed that '' does not denote an end-of-line character. Pascal specifically bans multi-line string/char literals.

Answer 29

Python 3, 33 bytes

for x in range(ord("e")):print(x)

Answer 30

Elixir, 26 bytes

for x<-0..?d,do: IO.puts x

Try it online!