[Question]
  [
Print integers 0 to 100 (inclusive) without using characters `123456789` in your code.
Separator of numbers can be comma or [white space](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_442) (by default <blank>, <horizontal tabulator>, <newline>, <carriage return>, <form feed> or <vertical tabulator>).
Shortest code wins.
  
[Answer]
# [R](https://www.r-project.org/), 9 bytes
```
F:volcano
```
[Try it online!](https://tio.run/##K/r/382qLD8nOTEv//9/AA "R ‚Äì Try It Online")
The sequence operator `:` coerces its arguments to integers. `F` is the boolean `FALSE`, which gets coerced to `0`. `volcano` is one of the many built-in datasets (it gives topographic information about Maunga Whau in New Zealand); since it is a matrix, `:` fetches the value at position `[1, 1]` which is luckily equal to `100`. The code is therefore equivalent to `0:100`.
This answer was inspired by a conversation with Giuseppe and Kirill L. in the comments under [Giuseppe's R answer](https://codegolf.stackexchange.com/a/219592/86301).
[Answer]
# Python 3: 27 23 20 Bytes
*Thanks to caird coinheringaahing for -4 bytes, ovs for -3 bytes*
```
print(*range(*b'e'))
```
I'm pretty poor at golfing, so there's probably a better way to do this.
[TIO](https://tio.run/##K6gsycjPM/7/v6AoM69EQ6soMS89VUMrST1VXVPz/38A)
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 138 bytes
```
>>++++++++++<<++++++[>>>++++++++<<<-]++++++[>>>>++++++++<<<<-]++++++++++>++++++++++<[>[>>.>.+<<.<-]++++++++++>>>----------<+<<<-]>>>>+.-..
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v/fzk4bDmxsIHS0HULUxsZGNxYhjCwOlwABZGOi7YBK9ez0gIr0UBXZ2enCgQ3EbLCherp6ev//AwA "brainfuck ‚Äì Try It Online")
No numbers is pretty easy, but the golf size is not great... :)
I am sure it can be improved, I am really a beginner in using Brainfuck. I wanted to try it anyway.
**How it works:**
```
>>++++++++++<<                LF Char (idx2)
++++++[>>>++++++++<<<-]       Zero char tens (idx3)
++++++[>>>>++++++++<<<<-]     Zero char unit (idx4)
+++++ +++++                   10 counter (tens)
>+++++ +++++<                 10 counter (unit)
[>                            Move to the counter
  [>>.                        Print the tens
    >.+                       Print the unit and increment
     <<.                      Print the LF
       <-]                    Loop 10 times
+++++ +++++                   Restore the counter
>>>----- -----                Restore the digit
  <+                          Increment the tens char
    <<<-]                     Loop everything 10 times
>>>>+.-..                     Print 100 using a cell which is already at char 0
```
[Answer]
# [JavaScript (V8)](https://v8.dev/), 28 bytes
We cannot write \$100\$ or \$101\$ in hexadecimal with 0's and letters only (**0x64** and **0x65** respectively), but we can write \$202\$ (**0xCA**) and use \$2n<202\$ as the condition of the `for` loop.
```
for(n=0;n+n<0xCA;)print(n++)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/Py2/SCPP1sA6TzvPxqDC2dFas6AoM69EI09bW/P/fwA "JavaScript (V8) ‚Äì Try It Online")
---
### 30 bytes
This version computes \$10^2\$ with the hexadecimal representation of \$10\$.
```
for(n=0;n<=0xA*0xA;)print(n++)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/Py2/SCPP1sA6z8bWoMJRC4itNQuKMvNKNPK0tTX//wcA "JavaScript (V8) ‚Äì Try It Online")
---
### 31 bytes
This version builds the string `"100"`.
```
for(n=0;n<=-~0+'00';)print(n++)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/Py2/SCPP1sA6z8ZWt85AW93AQN1as6AoM69EI09bW/P/fwA "JavaScript (V8) ‚Äì Try It Online")
[Answer]
# [SHENZHEN I/O](https://www.zachtronics.com/shenzhen-io/), 61 bytes, 7¬•, 7 Lines
```
@not
@mov acc dat
@not
tgt acc dat
-mov acc p0
-add x0
slp x0
```
Outputs 0-100 as simple output, one per time unit. Makes use of the DX300 (XBus <-> Simple Input chip) and LC70G04 (NOT gate), which cost 1¬• each but do not use any power or count as lines of code (the game's measure of code length). These are used to generate a value of 1, which it adds and outputs until it hits 100. The value for 100 is generated using the "not" command, which makes the accumulator 100 if it is value 0, otherwise it sets the acc to 0.
[![](https://i.stack.imgur.com/CpUon.gif)](https://i.stack.imgur.com/CpUon.gif)
(Not pictured: conversion from simple output to the screen's XBus input, for the visualization.)
---
# [SHENZHEN I/O](https://www.zachtronics.com/shenzhen-io/) (MCxxxx ASM only), 129 bytes, 8¬•, 16 Lines
```
@not                 | not
@mov acc p0          | mul acc
@mov acc dat         | dgt 0
@not                 | sub p0
add p0               | dgt 0
tgt acc dat          | mul acc
-mov acc x0          | mov acc p0
slp p0               | slx x0
```
Outputs 0-100 as one XBus output each. Uses only programmable MCxxxx chips, no logic gates or other components. Generates value 1 in a pretty interesting way:
```
not     # acc = 100
mul acc # 100 * 100 = 999 (max value)
dgt 0   # digit 0 of 999 = 9
sub p0  # 9 - 100 = -91
dgt 0   # digit 0 of -91 = -1
mul acc # -1 * -1 = 1
```
[![enter image description here](https://i.stack.imgur.com/RgZX8.gif)](https://i.stack.imgur.com/RgZX8.gif)
[Answer]
# [Raku](http://raku.org/), 10 bytes
```
put 0..‚Ö≠
```
[Try it online!](https://tio.run/##K0gtyjH7/7@gtETBQE/vUeva//8B "Perl 6 ‚Äì Try It Online")
`‚Ö≠` here is the Unicode character ROMAN NUMERAL ONE HUNDRED.
Any other Unicode character with a defined value of 100 could be used:
‡Ø±: TAMIL NUMBER ONE HUNDRED  
‡µ±: MALAYALAM NUMBER ONE HUNDRED  
·çª: ETHIOPIC NUMBER HUNDRED  
‚ÖΩ: SMALL ROMAN NUMERAL ONE HUNDRED  
‰Ω∞: CJK UNIFIED IDEOGRAPH-4F70  
Áôæ: CJK UNIFIED IDEOGRAPH-767E  
Èôå: CJK UNIFIED IDEOGRAPH-964C
All are three UTF-8 bytes long, like `‚Ö≠`.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 2 [bytes](https://github.com/DennisMitchell/jellylanguage/wiki/Code-page)
```
¬≥≈ª
```
[Try it online!](https://tio.run/##y0rNyan8///Q5qO7//8HAA "Jelly ‚Äì Try It Online")
Outputs a list. If the separator must be a single character, [3 bytes](https://tio.run/##y0rNyan8///Q5qO7vf//BwA)
## How it works
```
¬≥≈ªK - Main link. Takes no arguments
¬≥   - Yield 100
 ≈ª  - Range from 0 to 100
  K - Join by spaces (optional)
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `jHRM`, 0 bytes
```
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJqSFJNIiwiIiwiIiwiIiwiIl0=)
Kinda cheating, but whatever.
## How?
```
  # full program
  # H flag presets the stack to 100
  # R flag does range when number is treated as iterable
  # M flag makes range start at 0
  # j flag joins the top of the stack by newlines
```
[Answer]
# [R](https://www.r-project.org/), 11 bytes
```
F:(0xA*0xA)
F:0xA^(T+T)
```
[Try it online!](https://tio.run/##K/r/381Kw6DCUQuINf//BwA "R ‚Äì Try It Online")
Uses [this tip](https://codegolf.stackexchange.com/a/191117/67312).
Still being beaten by [some volcano in New Zealand](https://codegolf.stackexchange.com/a/219617/67312), though...
Old answer:
### [R](https://www.r-project.org/), 16 bytes
```
F:paste0(+T,0,0)
```
[Try it online!](https://tio.run/##K/r/382qILG4JNVAQztEx0DHQPP/fwA "R ‚Äì Try It Online")
Thanks to Kirill L. for correcting an error.
R's ASCII=>byte function is `utf8ToInt`, which unfortunately has an `8` in it. Luckily, `:` will attempt to coerce its arguments to numeric types, so we construct `100` by pasting together `+F` (which coerces its value to `0`) and two `0`s. This would also work, though longer, without a `0` as `F:paste(+T,+F,+F,sep="")`.
Possibly there's a very short builtin dataset with a `sum` that's close to 100, though I haven't been able to find one.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~33~~ ~~26~~ 24 bytes
```
,,
,,,,,,
,
,,,,,
$.`
```
[Try it online!](https://tio.run/##K0otycxL/P@fS0eHC4hBgEsHwuDiUtFL@P8fAA "Retina 0.8.2 ‚Äì Try It Online") Explanation: The first stage inserts two commas, which the second stage increases to 20 (it's complicated). The third stage multiplies by 5 to give 100. The last stage then inserts the number of commas so far at each position.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 38 bytes
```
f(i){for(i=0;printf("%d ",i++)&'#';);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NI1OzOi2/SCPT1sC6oCgzryRNQ0k1RUFJJ1NbW1NNXVndWtO69n9uYmaeBlChBojzLzktJzG9@L9uOQA "C (gcc) ‚Äì Try It Online")
Without using digit `0`, it would be 39 bytes: [`i;main(){for(;printf("%d ",i++)&'#';);}`](https://tio.run/##S9ZNT07@/z/TOjcxM09Dszotv0jDuqAoM68kTUNJNUVBSSdTW1tTTV1Z3VrTuvb//3/JaTmJ6cX/dcsB)
[Answer]
# [Bash](https://www.gnu.org/software/bash/), ~~25~~ 23 bytes
```
seq 0 $(printf %d "'d")
```
[Try it online!](https://tio.run/##S0oszvj/vzi1UMFAQUWjoCgzryRNQTVFQUk9RUnz/38A "Bash ‚Äì Try It Online")
-2 thanks to @manatwork
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 16 12 bytes
-4 bytes thanks to @mazzy!
```
0..(0xa*0xa)
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/30BPT8OgIlELiDX//wcA "PowerShell ‚Äì Try It Online")
[Answer]
# PHP, 30 bytes
First time golfing, I hope I posted this right!
```
while($q<ord(e))echo+$q++,' ';
```
[Try it online!](https://tio.run/##K8go@G9jXwAkyzMyc1I1VApt8otSNFI1NVOTM/K1VQq1tXXUFdSt//8HAA "PHP ‚Äì Try It Online")
---
Thanks to [manatwork](https://codegolf.stackexchange.com/users/4198/manatwork) and [Dewi Morgan](https://codegolf.stackexchange.com/users/41364/dewi-morgan)'s suggestions to improving the code! From 34 to 30 bytes!
The code revisions are in the edit history, removed here so it looks cleaner!
[Answer]
# Factor, ~~46~~ 23 bytes
-23 bytes thanks to Bubbler
```
0xa sq [0,b] [ . ] each
```
[Try it online!](https://tio.run/##qyrO@J@cWKJgp1Cnr5eWmFySX6RblKxgY6Pg6u/GFRrsaqVQkFhUnFqkkFhakq9bWpzKBZKAaSnOLy1KToVqhOr6b1CRqFBcqBBtoJMUqxCtoKcQq5CamJzxH6RRP7@gRB@iHEqhm/IfAA "Zsh ‚Äì Try It Online")
I've never written anything in Factor before, but it's a surprisingly fun language.
[Answer]
# [Zsh](https://www.zsh.org/), 12 bytes
```
seq 0 $[##d]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m724qjhjwYKlpSVpuhZrilMLFQwUVKKVlVNiIUJQGZgKAA)
* `seq`: count
	+ from `0`
	+ `$[##d]`: to the character value of `d`
Alternative:
# [Zsh](https://www.zsh.org/), 12 bytes
```
!
seq 0 $?00
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m724qjhjwYKlpSVpuhZrFLmKUwsVDBRU7A0MIEJQGZgKAA)
`!` does nothing, but fails with exit code 1; `$?` then retrieves the exit code.
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), `jH`, 1 byte
```
 Ä
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=jH&code=%CA%80&inputs=&header=&footer=)
Flags for the win. The `H` flag presets the stack to 100, generate range 0 to 100 and then `j` flag joins on newlines. The flag was around before this challenge too.
[Answer]
# Perl, 20, 13, 12, 16 bytes
```
say for 0..ord d 
```
[Try it online!](https://tio.run/##K0gtyjH9X1qcqlBmqmdoYP2/OLFSIS2/SMFATy@/KEUh5f9/AA "Perl 5 ‚Äì Try It Online")
[Answer]
# [Zsh](https://www.zsh.org/), 16 bytes
```
echo {0..$[##d]}
```
[Try it online!](https://tio.run/##qyrO@P8/NTkjX6HaQE9PJVpZOSW29v9/AA "Zsh ‚Äì Try It Online")
Only builtins, so no `seq`
---
For fun, here's a **17 byte** answer without `0`:
```
echo {$?..$[##d]}
```
[Try it online!](https://tio.run/##qyrO@P8/NTkjX6FaRVlPTyVaWTkltvb/fwA "Zsh ‚Äì Try It Online")
Also `$!` or `$#` will work as `0` replacements.
[Answer]
# [Bash](https://www.gnu.org/software/bash/), ~~18~~ ~~16~~ 14 bytes
```
seq 0 $[++x]00
```
[Try it online!](https://tio.run/##S0oszvj/vzi1UMFAQSVaW7si1sDg/38A "Bash ‚Äì Try It Online")
Thanks @manatwork for -2, @Jonah for -2
[Answer]
# PICO-8, ~~50~~ 45 bytes
```
i=0-#"0"repeat i+=#"0"?i
until#tostr(i)>#"00"
```
-5 bytes by replacing `print` with its shorthand, `?`.
Demo (50 byte version; 45 byte version has same output):
[![i=0-#"0"repeat i+=#"0"print(i)until#tostr(i)>#"00"](https://i.stack.imgur.com/GWfVa.gif)](https://i.stack.imgur.com/GWfVa.gif)
[Answer]
# GNU Octave, 14, 5 bytes
```
0:'d'
```
[TIO](https://tio.run/##y08uSSxL/f/fwEo9Rf3/fwA) by Giuseppe
[Answer]
# [Ruby](https://www.ruby-lang.org/) 22 bytes  12 bytes - thanks to @manatwork
```
p *0..?d.ord
```
[Try it online!](https://tio.run/##KypNqvz/v0BBy0BPzz5FL78o5f9/AA "Ruby ‚Äì Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 2 bytes
```
—Ç√ù
```
[Try it online!](https://tio.run/##yy9OTMpM/f//YtPhuf//AwA "05AB1E ‚Äì Try It Online")
Outputs a list. If the separator must be a single character, [3 bytes](https://tio.run/##yy9OTMpM/f//YtPhuYd2//8PAA)
## How it works
```
—Ç√ù¬ª - Full program
—Ç   - Push 100
 √ù  - Range from 0 to 100
  ¬ª - Join with newlines (optional)
```
[Answer]
# Deadfish~, 2071 / 8 / 7 bytes
2071 bytes
```
o{i}c{d}io{i}dc{d}iio{i}ddc{d}iiio{i}dddcddddddoiiiiiicdddddoiiiiicddddoiiiicdddoiiicddoiicdoicociodciioddciiiodddciiiioddddciiiiiodddddciiiiiioddddddc{i}dddo{d}iiic{i}ddo{d}iic{i}do{d}ic{i}o{d}c{i}io{d}dc{i}iio{d}ddc{i}iiio{d}dddc{i}iiiio{d}ddddc{i}iiiiio{d}dddddc{i}iiiiiio{d}ddddddc{i}{i}dddo{d}{d}iiic{i}{i}ddo{d}{d}iic{i}{i}do{d}{d}ic{i}{i}o{d}{d}c{i}{i}io{d}{d}dc{i}{i}iio{d}{d}ddc{i}{i}iiio{d}{d}dddc{i}{i}iiiio{d}{d}ddddc{i}{i}iiiiio{d}{d}dddddc{i}{i}iiiiiio{d}{d}ddddddc{i}{i}{i}dddo{d}{d}{d}iiic{i}{i}{i}ddo{d}{d}{d}iic{i}{i}{i}do{d}{d}{d}ic{i}{i}{i}o{d}{d}{d}c{i}{i}{i}io{d}{d}{d}dc{i}{i}{i}iio{d}{d}{d}ddc{i}{i}{i}iiio{d}{d}{d}dddc{i}{i}{i}iiiio{d}{d}{d}ddddc{i}{i}{i}iiiiio{d}{d}{d}dddddc{i}{i}{i}iiiiiio{d}{d}{d}ddddddc{{i}dddddd}dddo{{d}iiiiii}iiic{{i}dddddd}ddo{{d}iiiiii}iic{{i}dddddd}do{{d}iiiiii}ic{{i}dddddd}o{{d}iiiiii}c{{i}dddddd}io{{d}iiiiii}dc{{i}dddddd}iio{{d}iiiiii}ddc{{i}dddddd}iiio{{d}iiiiii}dddc{{i}dddddd}iiiio{{d}iiiiii}ddddc{{i}dddddd}iiiiio{{d}iiiiii}dddddc{{i}dddddd}iiiiiio{{d}iiiiii}ddddddc{{i}ddddd}dddo{{d}iiiii}iiic{{i}ddddd}ddo{{d}iiiii}iic{{i}ddddd}do{{d}iiiii}ic{{i}ddddd}o{{d}iiiii}c{{i}ddddd}io{{d}iiiii}dc{{i}ddddd}iio{{d}iiiii}ddc{{i}ddddd}iiio{{d}iiiii}dddc{{i}ddddd}iiiio{{d}iiiii}ddddc{{i}ddddd}iiiiio{{d}iiiii}dddddc{{i}ddddd}iiiiiio{{d}iiiii}ddddddc{{i}dddd}dddo{{d}iiii}iiic{{i}dddd}ddo{{d}iiii}iic{{i}dddd}do{{d}iiii}ic{{i}dddd}o{{d}iiii}c{{i}dddd}io{{d}iiii}dc{{i}dddd}iio{{d}iiii}ddc{{i}dddd}iiio{{d}iiii}dddc{{i}dddd}iiiio{{d}iiii}ddddc{{i}dddd}iiiiio{{d}iiii}dddddc{{i}dddd}iiiiiio{{d}iiii}ddddddc{{i}ddd}dddo{{d}iii}iiic{{i}ddd}ddo{{d}iii}iic{{i}ddd}do{{d}iii}ic{{i}ddd}o{{d}iii}c{{i}ddd}io{{d}iii}dc{{i}ddd}iio{{d}iii}ddc{{i}ddd}iiio{{d}iii}dddc{{i}ddd}iiiio{{d}iii}ddddc{{i}ddd}iiiiio{{d}iii}dddddc{{i}ddd}iiiiiio{{d}iii}ddddddc{{i}dd}dddo{{d}ii}iiic{{i}dd}ddo{{d}ii}iic{{i}dd}do{{d}ii}ic{{i}dd}o{{d}ii}c{{i}dd}io{{d}ii}dc{{i}dd}iio{{d}ii}ddc{{i}dd}iiio{{d}ii}dddc{{i}dd}iiiio{{d}ii}ddddc{{i}dd}iiiiio{{d}ii}dddddc{{i}dd}iiiiiio{{d}ii}ddddddc{{i}d}dddo{{d}i}iiic{{i}d}ddo{{d}i}iic{{i}d}do{{d}i}ic{{i}d}o{{d}i}c
```
[Try it online!](https://tio.run/##ZZBBcsUgDENP1EN1oJ2yyqLLDmdPg8H2k5NFIsv8j57612f/Hr8/H/d9/Y3Z/vocS3RTWx59ht66Pdewp2FoIdsRzT7tebWrjau351/6eq@PfU1steXRZ3jutkuvHWFPezBtcqkl1ncsYb8aWx59Bp98jDmMdNIyL4NklogTiTyU5zrRTjoP6BkjZiTNsJkXkZGawZld4lcCgRAOopAGQGBKrCQDHPiISEoBFVbFVeICXbgrOug3@PNs/o3@PLsBbnUpO1lxwwX9wYWkGLoqu7Ks27p@7V8H3ifeR3BGS9KOZllxwwV82HCRgN1INdKMFqO9lFpKK7WU2smrktqIFCJ9TF3Ah51umunlveiBNbAFKUE60Aq0gVJA4a/4hZ7wZJ9ip5tmeGGFE7clM5BBTGDyCq7QKqyyFlQlBSg4J83wwnLHDZ/9juBLvKQDHNiIRjIBEy7FEqqESqYJyx03znzGdt// "Deadfish~ ‚Äì Try It Online")
8 bytes (if you consider Hello, world! a valid separator)
```
o{{iow}}
```
[Try it online!](https://tio.run/##S0lNTEnLLM7Q/f8/v7o6M7@8tvb/fwA "Deadfish~ ‚Äì Try It Online")
7 bytes (If you don't care about seperators)
```
o{{io}}
```
[Try it online!](https://tio.run/##S0lNTEnLLM7Q/f8/v7o6M7@29v9/AA "Deadfish~ ‚Äì Try It Online")
Never thought I'd see deadfish be shorter than, well, anything except Unary.
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 13 characters
Thanks to
* [Daemon](https://codegolf.stackexchange.com/users/101144/daemon) for reusing stack depth instead of getting it again, to use shorter operator (-1 character)
```
[zpdA0>x]dsxx
```
[Try it online!](https://tio.run/##S0n@/z@6qiDF0cCuIjaluKLi/38A "dc ‚Äì Try It Online")
### [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 14 characters
Thanks to
* [Digital Trauma](https://codegolf.stackexchange.com/users/11259/digital-trauma) for the twist in using the stack depth efficiently (-2 characters)
```
[zpzA0!<m]dsmx
```
[Try it online!](https://tio.run/##S0n@/z@6qqDK0UDRJjc2pTi34v9/AA "dc ‚Äì Try It Online")
### [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 16 characters
```
0[pz+dA0>i]dsixp
```
Sample run:
```
bash-5.0$ dc -e '0[pz+dA0>i]dsixp' | head
0
1
2
3
4
5
6
7
8
9
```
[Try it online!](https://tio.run/##S0n@/98guqBKO8XRwC4zNqU4s6Lg/38A "dc ‚Äì Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/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".
[![enter image description here](https://i.stack.imgur.com/cNtqU.png)](https://i.stack.imgur.com/cNtqU.png)
[Answer]
# 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](https://www.online-python.com/pwafv3OSPz).
# Python 3 25 Bytes
```
print(*range(0xa*0xa-~0))
```
`How it works?` 0xa = 10, ~0 = -1, -~0 = 1 (equivalent to -1\*-1)
[Answer]
# [Python](https://python.org), ~~25~~ 23 bytes
```
print(*range(ord('e')))
```
-2 by Steffan, remove first parameter (`0`) from call to `range`
[Answer]
# [APL (Dyalog)](https://dyalog.com/), 19 bytes
```
‚éï‚Üê0,‚ç≥(+/‚ç≥‚â¢‚ç¨‚ç¨‚ç¨‚ç¨)*‚â¢‚ç¨‚ç¨
```
[Try it here!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v//Ud/UR20TDHQe9W7W0NYHko86Fz3qXQNHmlpwgf//AQ)
```
‚â¢‚ç¨‚ç¨‚ç¨‚ç¨ ‚çù 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
```
]