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

AWK, 26 bytes

{for(;a<=0xa*0xa;)$a=a++}a

Try it online!

Thanks to xnor for pointing out a brainfart (since fixed) in the original

This works by using 0xa*0xa to compute 100, then assigns each positional variable to it's own sequential number. Then the a without a code block (evaluates as truthy since a is 100) prints all the positional arguments separated by a space.

To be honest, I'm not 100% sure why the 0 prints but it does. :)

Answer 2

Whitespace, 58 bytes

Another in the theme of "this language doesn't even care about digit characters".

Try it online!

The program with comments:

[Push  0 
][Label
  
][Dup 
 ][PrintNum	
 	][Push  10 	 	 
][PrintChar	
  ][Push  1 	
][Add	   ][Dup 
 ][Push  101 		  	 	
][Subtract	  	][JmpNeg
		
]

Try it online!

Answer 3

Vim, 20 bytes

i0<esc><C-A>s<C-R>=range(<C-R>"0<C-R>")

Try it online!

Trying to improve on Razetime's answer, I stumbled upon the range function, which works wonders for this task. i<C-R>=range(101)\n would print the numbers we want, we just need to be a little creative to do it without 1.

Explanation

i0<esc><C-A>s<C-R>=range(<C-R>"0<C-R>")
i0<esc>                                    Insert a single 0
       <C-A>                               Increase it to a 1
            s                              Cut the 1 and go back to insert mode
             <C-R>=                        Write the result of the following function
                   range(             )    A range of numbers from 0 to N-1
                         <C-R>"            The last text that was deleted (1)
                               0           0
                                <C-R>"     1 again

Answer 4

v³, 96 93 bytes

^+++(###....+###....+++<..#+...-....###+.@#+...$)+).>+++.$#+...^##=.+###.-#+....+)<++(-+##++>

Unwrapped:

        ^ + + +
        ( # # #
        . . . .
        + # # #
. . . . + + + < . . # + . . . -
. . . . # # # + . @ # + . . . $
) + ) . > + + + . $ # + . . . ^
# # = . + # # # . - # + . . . .
        + ) < +
        + ( - +
        # # + +
        > . . .

I'm not able to provide a direct link, but here you should be able to fork the project and replace the script.txt with either of the above scripts.

Answer 5

Befunge-93, 16 13 bytes

Thanks to @Cinaski for saving 3 bytes with \! instead of "ba"-.

:.\!+:"d"`#@_

Try it online!

Uses \! to NOT the 0 at the bottom of the stack and uses that to increment the loop, then tests if the counter is greater than d to end. Certainly not the shortest answer, but this is my first golf challenge, and I wanted to practice Befunge, which I decided to pick up yesterday. This is also my first time trying a stack-based language, and I'm having a lot of fun with it.

Answer 6

Wolfram Language (Mathematica), 15 14 11 bytes

=Range[0,LL

-1 byte from Imanton1

Mathematica interprets the = prefix as a call to Wolfram Alpha (auto-converting it to the orange glyph seen below), which in turn interprets "LL" as a Roman numeral for 100. I used "LL" because this doesn't work with the shorter "C".

Answer 7

Python 3 20 Bytes

print(*range(*b'e'))

How it works? Basically, doing *b'char' is equivalent to ord('char'), and in this case ord('e') is equal to 101 ; Lets re-create the ord() function!

Ord Function Recreation (Not the answer! Just a demonstration on how ord() works)

ord=lambda x:(int(*bytes(x, 'ascii')))

As you can see it works! You can test this yourself here.

Python 3 25 Bytes

print(*range(0xa*0xa-~0))

How it works? 0xa = 10, ~0 = -1, -~0 = 1 (equivalent to -1*-1)

Answer 8

Desmos, 25 bytes

o=0
o->[0...eeeln(eeeee)]

Not sure if this is an acceptable form of output but it's still an interesting answer imo. Click the right arrow (->) to run.

Try It On Desmos!

This takes advantage of Desmos's implicit rounding with list ranges, which will always round both start and end numbers to the nearest integer. In this case, eeeln(eeeee) is mathematically equivalent to \$e^3\cdot5\approx100.42768\$ (\$e\approx2.71828\$ is Euler's number), which rounds down to 100.

If not acceptable, then here's an alternative version that might be more acceptable:

31 bytes

l=[0...eeeln(eeeee)]
(l,0)
${l}

Paste first two equations into Desmos, and label the list of points (l,0) as ${l}. Move the viewport to the right to view more numbers.

Try It On Desmos!

Answer 9

APL (Dyalog), 19 bytes

⎕←0,⍳(+/⍳≢⍬⍬⍬⍬)*≢⍬⍬

Try it here!

≢⍬⍬⍬⍬ ⍝ This evaluates to 4
≢⍬⍬ ⍝ This evaluates to 2

⍳≢⍬⍬⍬⍬ ⍝ Evaluates to 1 2 3 4
(+/⍳≢⍬⍬⍬⍬) ⍝ Sums up previous list, 1+2+3+4 = 10
(+/⍳≢⍬⍬⍬⍬)*≢⍬⍬ ⍝ Exponentiates previous result by 2
⍳(+/⍳≢⍬⍬⍬⍬)*≢⍬⍬ ⍝ Generates 1 2 ... 100
0,⍳(+/⍳≢⍬⍬⍬⍬)*≢⍬⍬ ⍝ Appends 0 to front

Answer 10

jq, 20 characters

range("e"|explode[])

Sample run:

bash-5.0$ jq -n 'range("e"|explode[])' | head
0
1
2
3
4
5
6
7
8
9

Try it online!

Answer 11

Lua (34 30 bytes)

for i=0,0xA*0xA do print(i)end

Answer 12

MATLAB, 13 bytes

0:double('d')

The ASCII code for lowercase d is 100, so convert to a double and go from 0 in intervals of 1 with ":"

Answer 13

Wolfram Language (Mathematica), 20 bytes

The only real golfing opportunity for this question in the Wolfram language is to encode the number 100 with as few bytes as possible. There is only one real-valued constant symbol in the Wolfram language with a one byte name, namely E.

I thus looked for combinations of binary operations that were near 100. (E+E)^E is about 99.73, so adding E/E will give a suitable endpoint.

Range[0,(E+E)^E+E/E]

Try it online!

Answer 14

Vim, 21 bytes

qqYP<C-x>qi0<esc><C-a>a00@q<esc>Yxx@0

Try it online!

Explanation

qq       q                             Record macro q:
  Y                                     Yank the current line
   P                                    Paste a copy of it on the line above
    <C-x>                               Decrement the number under the cursor
          i0<esc>                      Insert a 0
                 <C-a>                 Increment it to 1
                      a00@q<esc>       Append 00@q
                                Y      Yank this line (100@q)
                                 xx    Delete the @q part
                                   @0  Execute the yanked text as commands
                                       (100@q executes the q macro 100 times)

Answer 15

Rust, 41 40 39 35 bytes

^{Thanks to Redwolf for -1 byte, Unrelated String for -4}

||for i in 0..b'e'{print!("{} ",i)}

Try it online!

 

---

39 bytes

||(0..b'e').all(|i|print!("{} ",i)==())

Try it online!

---

40 bytes

||(0..b'e').for_each(|i|print!("{} ",i))

Try it online!

Answer 16

C - 37 Bytes

i;f(){while(i<'e')printf("%d",i++);}

Ungolfed

i;
f()
{
    while(i < 'e')
        printf("%d", i++);
}

Explanation

Function to print numbers from 0 to 100 without digits. A global variable of type integer is created (so that it is automatically initialized to 0), the variable is incremented and printed 100 times through a loop which is executed while the variable is less than 'e' or 101 in ASCII.

Answer 17

PostScript: 11 bytes

00000000: 8800 8801 8864 7b3d 7d92 48              .....d{=}.H

A tokenized version of 0 1 100{=}for.

Answer 18

BBC BASIC, 29 19 bytes

I have revisited my first answer that I have posted more than 3 years ago and found out that the bytecount could be significantly reduced:

• -4 bytes thanks to @Neil for the comment he left more than 3 years ago! (Substituting 7 bytes PRINT i with 3 bytes P.i. Note that the alias P. is majuscule.)
• then again, -4 bytes by doing the analogous replacement of FOR i (5 bytes) with F.i (3 bytes) and NEXT with N.
• -2 bytes: removal of two spaces

F.i=0TO&A*&A
P.i
N.

MY-BASIC, 32 bytes

for i=0 to 0xa*0xa
print i;
next

Try it online!

Edit: Thanks for upvoting! This has been my original golf but it has turned out that BBC BASIC has an even shorter syntax for hexadecimals as well as handy for golfing aliases :)

Answer 19

Powershell, 18 bytes

0..[byte][char]'d'

Answer 20

APL(Dyalog Unicode), 8 bytes ^SBCS

⍳⎕UCS'e'

Try it on APLgolf!

A tradfn submission which prints with space separator.

Answer 21

Julia 1.0, 19 bytes

println.(0:0xA*0xA)

Try it online!

Answer 22

bc, 17 bytes

for(;i<=A*A;i++)i

Try it online!

Answer 23

K (ngn/k), 6 bytes

!0+"e"

Try it online!

Uses 0+ to convert "e" to an integer, then takes the range from 0 up to, but not including, that value (101).

Answer 24

Rattle, 14 bytes

i+R`c0c0$[+i]~

Try it online!

Explanation

i                    prints the value at the top of the stack (0) 
 +                   adds 1 to the value on top of the stack (which was 0, is now 1.0)
  R`                 reformats the top of the stack with the arg ` (the value at the top of the stack).
                        since ` = 1, it reformats the top of the stack as the integer 1
    c0c0             concatenates the value in storage at the current pointer (=0) to the top of the 
                        stack twice, resulting in "100"
        $            swaps the value on top of the stack (100) with the value in storage at the 
                        current pointer (0)
         [ .... ]~   loop structure: loops ~ times, where ~ = value_in_storage_at_pointer = 100
            +        adds one to the value on top of the stack
             i       prints the top of the stack as an integer

Note: the above code is based on version 1.0.* of Rattle. With the newest update (1.1.0), the code could be shortened to the following snippet (12 bytes) because the addition operator will now keep the top of the stack the same type (in this case, an integer) if possible.

i+c0c0$[+i]~

Answer 25

Bash, 26 bytes

eval echo {$[x++]..${x}00}

Try it online!

(Previously)

Bash, 28 bytes

eval echo {$((++x))..${x}00}

Try it online!

Answer 26

Arn -h, 2 bytes

PS. You need to hand-type that flag because the permalink for flags is not working.

0|

Try it

Explained

0   # 0
 |  # concatenated with
    # (implicit) the range [1 .. 100]

Implicit output

Answer 27

Zig, 63 66 47 72 bytes

fn a()void{for(" "**'e')|_,i|{@import("std").debug.print("{d} ",.{i});}}

Try it online!

I've excluded the @import() boilerplate as it seems analogous to C's #include, which is excluded from other answers. If deemed necessary, I will add it back in.

Explanation

fn a() void {
    for (" " ** 'e') |_, i| {
        @import("std").debug.print("{d} ",.{i});
    }
}

• fn a() void Declare a function which takes no parameters and returns nothing
• for () |_, i| For every item in the array inside of (), iterate and capture the entree as _ (a throwaway variable) and the index as i
• " " ** 'e' Take the string (strings are slices, or pointer-arrays which know their length) and repeat it 'e' (101) times
• ** Requires a little bit more more explanation I think: In Zig, there is the concept of "comptime" (compile time) and runtime. ** is an operator which repeats any array literal or slice literal at comptime, because the resulting length is still known to the compiler.
• @import("std").debug.print("",.{}); Print to STDERR (I believe that's valid for this question, right?), the first argument is the formatting string, and the second is an "anonymous sctruct"/tuple with a variable number of arguments in it (Zig doesn't have var-args).
• "{d} " The format string. Zig denotes {} as the formatting characters, with d meaning a digit in this case.

Answer 28

Rust, 46 bytes

I did not see a rust solution, so here's my attempt:

||print!("{:?}",(0..b'e').collect::<Vec<_>>())

Try it online!

Thanks to @ovs for pointing out the closure variant.

The range (0..b'e') is collected into a vector (using the placeholder _, letting the compiler figure out the type) and printed using the debug formatter {:?}, which "dumps" the entire vector.

The range upper bound is exclusive, and is represented using the byte literal b'e', which is equivalent to an u8 integer number literal; in this case 101 (e's ASCII value).

Answer 29

C, 53 bytes

int main(a,b){for(;a^'f';a++){printf("%d\n",a-!!a);}}

Try it online!

43 42 bytes

(Thanks to Jo King♦)

k;main(){for(;k^'e';)printf("%d ",k++);}

Try it online!

Answer 30

KonamiCode, 54 50 55 bytes

v(>)>(^)v(^^^>^^)S(^>>^)>(>)L(>)<<<v((>))>(^)<<>(>)B(>)

A version with an explanation:

[You actually do need to inititalize address 0, my mistake. Also, my original version did not print 0.]

v(>) [Inititalizes address 0]
>(^) [Sets address pointer to 1, this is where the space character wil be held]
v(^^^>^^) [Writes 32 (a space) to memory]
S(^>>^) [Sets the comparison buffer to 101]
>(>) [Back to address 0]
L(>) [Loop marker]
<<< [Output the counter at address 0 as a number]
v((>)) [Increase the counter by 1]
>(^) [Goes to the space]
<< [Output the space]
>(>) [Back to 0]
B(>) [Done!]