title: Print 0 to 100 without 1-9 characters

text:
# Question
Title: Print 0 to 100 without 1-9 characters
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
# , 9 bytes

```
F:volcano

```

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.
> 141 votes

# 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
> 36 votes

# Answer
# brainfuck, 138 bytes

```
>>++++++++++<<++++++[>>>++++++++<<<-]++++++[>>>>++++++++<<<<-]++++++++++>++++++++++<[>[>>.>.+<<.<-]++++++++++>>>----------<+<<<-]>>>>+.-..

```

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

```
> 21 votes

# Answer
# JavaScript (V8), 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!

---

### 30 bytes

This version computes \\$10^2\\$ with the hexadecimal representation of \\$10\\$.

```
for(n=0;n<=0xA*0xA;)print(n++)

```

Try it online!

---

### 31 bytes

This version builds the string `"100"`.

```
for(n=0;n<=-~0+'00';)print(n++)

```

Try it online!
> 19 votes

# Answer
# SHENZHEN I/O, 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.

(Not pictured: conversion from simple output to the screen's XBus input, for the visualization.)

---

# SHENZHEN I/O (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
```
> 17 votes

# Answer
# Jelly, 2 bytes

```
³Ż

```

Try it online!

Outputs a list. If the separator must be a single character, 3 bytes

## How it works

```
³ŻK - Main link. Takes no arguments
³   - Yield 100
 Ż  - Range from 0 to 100
  K - Join by spaces (optional)

```
> 16 votes

# Answer
# Raku, 10 bytes

```
put 0..Ⅽ

```

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 .
> 16 votes

# Answer
# Vyxal `jHRM`, 0 bytes

```

```

Try it Online!

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

```
> 15 votes

# Answer
# , 11 bytes

```
F:(0xA*0xA)
F:0xA^(T+T)

```

Try it online!

Uses this tip.

Still being beaten by some volcano in New Zealand, though...

Old answer:

### , 16 bytes

```
F:paste0(+T,0,0)

```

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.
> 13 votes

# Answer
# Retina 0.8.2, ~~33~~ ~~26~~ 24 bytes

```

,,

,,,,,,
,
,,,,,

$.`

```

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.
> 12 votes

# Answer
# C (gcc), 38 bytes

```
f(i){for(i=0;printf("%d ",i++)&'#';);}

```

Try it online!

Without using digit `0`, it would be 39 bytes: `i;main(){for(;printf("%d ",i++)&'#';);}`
> 9 votes

# Answer
# Bash, ~~25~~ 23 bytes

```
seq 0 $(printf %d "'d")

```

Try it online!

-2 thanks to @manatwork
> 8 votes

# Answer
# PowerShell, 16 12 bytes

-4 bytes thanks to @mazzy!

```
0..(0xa*0xa)

```

Try it online!
> 8 votes

# Answer
# Zsh, 12 bytes

```
seq 0 $[##d]
```

Attempt This Online!

* `seq`: count
    + from `0`
    + `$[##d]`: to the character value of `d`

Alternative:

# Zsh, 12 bytes

```
!
seq 0 $?00
```

Attempt This Online!

`!` does nothing, but fails with exit code 1; `$?` then retrieves the exit code.
> 8 votes

# Answer
# PHP, 30 bytes

First time golfing, I hope I posted this right!

```
while($q<ord(e))echo+$q++,' ';

```

Try it online!

---

Thanks to manatwork and 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!
> 8 votes

# Answer
# Factor, ~~46~~ 23 bytes

-23 bytes thanks to Bubbler

```
0xa sq [0,b] [ . ] each

```

Try it online!

I've never written anything in Factor before, but it's a surprisingly fun language.
> 8 votes

# Answer
# Perl, 20, 13, 12, 16 bytes

```
say for 0..ord d

```

Try it online!
> 7 votes

# Answer
# Zsh, 16 bytes

```
echo {0..$[##d]}

```

Try it online!

Only builtins, so no `seq`

---

For fun, here's a **17 byte** answer without `0`:

```
echo {$?..$[##d]}

```

Try it online!

Also `$!` or `$#` will work as `0` replacements.
> 7 votes

# Answer
# Vyxal, `jH`, 1 byte

```
ʀ

```

Try it Online!

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

# Answer
# Bash, ~~18~~ ~~16~~ 14 bytes

```
seq 0 $[++x]00

```

Try it online!

Thanks @manatwork for -2, @Jonah for -2
> 7 votes

# 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):
> 7 votes

# Answer
# Bash, 15

```
seq `dc<<<A0Kf`

```

Try it online!

* 1 byte saved, thanks to @manatwork.

---

Previous answer:

# Pure Bash (no external utilities), 23

* 9 bytes saved thanks to @ArcticKona.

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

```

Try it online!
> 6 votes

# Answer
# Ruby 22 bytes  12 bytes - thanks to @manatwork

```
p *0..?d.ord

```

Try it online!
> 6 votes

# Answer
# GNU Octave, 14, 5 bytes

```
0:'d'

```

TIO by Giuseppe
> 6 votes

# Answer
# 05AB1E, 2 bytes

```
тÝ

```

Try it online!

Outputs a list. If the separator must be a single character, 3 bytes

## How it works

```
тÝ» - Full program
т   - Push 100
 Ý  - Range from 0 to 100
  » - Join with newlines (optional)

```
> 6 votes

# Answer
# dc, 13 characters

Thanks to

* Daemon for reusing stack depth instead of getting it again, to use shorter operator (-1 character)

```
[zpdA0>x]dsxx

```

Try it online!

### dc, 14 characters

Thanks to

* Digital Trauma for the twist in using the stack depth efficiently (-2 characters)

```
[zpzA0!<m]dsmx

```

Try it online!

### dc, 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!
> 6 votes

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

8 bytes (if you consider Hello, world! a valid separator)

```
o{{iow}}

```

Try it online!

7 bytes (If you don't care about seperators)

```
o{{io}}

```

Try it online!

Never thought I'd see deadfish be shorter than, well, anything except Unary.
> 6 votes

# Answer
# , ~~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.
> 6 votes

# Answer
# 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.
> 6 votes

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

```
> 6 votes

# Answer
# 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".
> 6 votes

# Answer
# Perl 5 (ppencode-compatible), 64 bytes

You didn't clarify that I must separate each with exactly one character, so here it is mine.

```
print length uc xor s qq q xor print while length ne ord qw q eq

```

Try it online!

## Explained

```
   # print(length) did not work for zero as $_ is not defined at then
   print length uc xor
   s qq q xor
   # delimiter
   print
while
   # equals to: length ne 101
   length ne ord qw q eq

```
> 6 votes

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

# Python 3 25 Bytes

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

```

`How it works?` 0xa = 10, ~0 = -1, -~0 = 1 (equivalent to -1\*-1)
> 6 votes

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

```
> 6 votes

# Answer
# Python, ~~25~~ 23 bytes

```
print(*range(ord('e')))

```

-2 by Steffan, remove first parameter (`0`) from call to `range`
> 6 votes

# Answer
# Javascript, 48 bytes

```
for(a of Array("e".charCodeAt()).keys())alert(a)

```

Can be shorter, if you allow in reverse (36 chars)

```
for(i="e".charCodeAt();--i;)alert(i)

```
> 5 votes

# Answer
# Lua (~~34~~ 30 bytes)

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

```
> 5 votes

# Answer
# 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. :)
> 5 votes

# Answer
# MY BASIC, 29 bytes; BBC BASIC 27 bytes

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

```

Try it online!

*Edit:* Thanks for upvoting! I have found there is a BASIC dialect with even shorter syntax for hexadecimals (it's in BBC BASIC):

```
for i=0 to &a*&a
print i
next

```

that's minus 2 bytes :)
> 5 votes

# Answer
# 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!
> 5 votes

# Answer
# 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 ":"
> 5 votes

# Answer
# 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!
> 5 votes

# Answer
# 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!
> 5 votes

# Answer
# 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!
> 5 votes

# Answer
# APL(Dyalog Unicode), 8 bytes SBCS

```
⍳⎕UCS'e'

```

Try it on APLgolf!

A tradfn submission which prints with space separator.
> 4 votes

# Answer
# 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!
> 4 votes

# Answer
# Julia 1.0, 19 bytes

```
println.(0:0xA*0xA)

```

Try it online!
> 4 votes

# Answer
# bc, 17 bytes

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

```

Try it online!
> 4 votes

# Answer
# 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]~

```
> 4 votes

# Answer
# 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).
> 4 votes

# Answer
# Bash, 26 bytes

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

```

Try it online!

## (Previously)

# Bash, 28 bytes

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

```

Try it online!
> 4 votes

# Answer
# unsure, 99 bytes

```
ummmmm uhhhh errrrr uhhh um errrrr um um yeah err heh but um yeah err then uh okay um err then wait

```

It's not the shortest.

Explanation:

```
push 101                  ummmmm uhhhh errrrr uhhh um errrrr
push 0 to other stack     um um yeah err heh
loop                      but ... wait
  decrement                 um yeah err
  print + increment other   then uh okay um err then

```
> 4 votes

# Answer
# 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)

```
> 4 votes

# Answer
# 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.
> 4 votes

# Answer
# 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).
> 4 votes

# Answer
# 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!
> 4 votes

# Answer
# 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.
> 4 votes

# Answer
# Python 3, 41 bytes

## Still learning ... best I could do:

```
for n in range(0, ord('e')):
    print(n)

```
> 4 votes

# Answer
# Minecraft, 217 bytes + ?

From left to right the commands in the command blocks are

```
scoreboard players operation a a += b a
tellraw @a {"score":{"name":"a","objective":"a"}}
scoreboard objectives add a dummy
scoreboard players set a a 0
execute store result score b a run data get entity @p playerGameType

```

The command blocks on the right set `a` to 0 and `b` to the `playerGameType` of the player, which is `1` if the player is in creative mode. The blocks on the left repeatedly print `a`, then add `b` to `a`. It's stopped at exactly 100 by the piston removing the repeater powering the command block.

I'm not sure how to score this or if it's even allowed but I thought it was kind of cool.
> 4 votes

# Answer
## PostScript: 11 bytes

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

```

A tokenized version of `0 1 100{=}for`.
> 4 votes

# Answer
# Powershell, 18 bytes

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

```
> 3 votes

# Answer
# Husk, 4 bytes

```
ŀc'e

```

Try it online!

Surprised Husk doesn't have a builtin for 100.

## How it works

```
ŀc'e - Main function, no arguments
  'e - Character literal "e"
 c   - Convert to charcode; 101
ŀ    - Lowered range; [0, 1, ..., 100]

```
> 3 votes

# Answer
# Befunge-98 (FBBI), ~~13~~ 11 bytes

```
.0!+::'e%j@

```

-1 byte thanks to @ovs

-1 byte thanks to @PizgenalFilegav

Try it online!
> 3 votes

# Answer
# MATL, ~~6~~ ~~5~~ 6 bytes

```
O'd'&:

```

Try it out at MATL Online

**Explanation**

```
O     % Letter O which is a pre-defined literal for zero
'd'   % String literal, 'd' (ASCII 100)
&:    % Create an array from 0...100
      % Implicitly print the result

```
> 3 votes

# Answer
# Japt, 2 bytes

```
òL

```

Try it online!

Calls the function `ò` on the variable `U` with the variable `L` as an argument. U is 0 when the program has no input, L is 100 whenever a program starts, and the function ò returns the inclusive range from "this" (U) to its first argument (L).

Also valid:

Calls the function `ò` on the variable `L` with no arguments. With no arguments `ò` returns the inclusive range from 0 to "this". This one ignores input, rather than requiring no input.
> 3 votes

# Answer
# Python 3, 96 bytes

```
import sys
n=0xb%0xa;m=0xa*0xa;p=lambda x:m if x>m else sys.stdout.write(str(x)+",")&p(x+n);p(n)

```

Try it online!
> 3 votes

# Answer
# PHP, 26 bytes

```
print_r(range(0,0xA*0xA));

```

Try it online!
> 3 votes

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

```
> 3 votes

# Answer
# Haskell \- ~~31~~ 19 bytes

**Edit:** From 31 bytes to 19 bytes, thanks to @binarycat's suggestion of using `fromEnum` instead of `ord`, which requires the Data.Char package.

~~Are imports cheating?~~

```
l=[0..fromEnum 'd']

```

Try it online!

## Explanation:

Convert 'd' into it's ASCII integer value using the `fromEnum` function, which gives 100 and generate a list from 0 to 100.
> 3 votes

# Answer
# Risky, ~~3~~ 2 bytes

```
0:--

```

Try it online!

```
range(100 - -1)

```
> 3 votes

# Answer
## javascript 77 bytes

```
let i=0;while(true){console.log(i);if(i.toString().includes('00'))break;i++;}

```
> 3 votes

# Answer
# AWK, ~~35~~ ~~34~~ 31 bytes

```
END{for(i;i<=0xA**2;)print i++}

```

Try it online!

-1 byte thanks to me

-3 bytes thanks to @cnamejj
> 3 votes

# Answer
# Shakespeare Programming Language, 218 bytes

```
,.Puck,.Ajax,.Act I:.Scene I:.[Exeunt][Enter Puck and Ajax]Puck:Open heart.You is the sum ofyou a cat.Ajax:You is twice the sum ofa big big cat a cat.Speak mind!You is the square ofyou.Is I nicer you?If notlet usAct I.

```

Try it online!

This is a golfed version based off of Dr Lemniscate's answer, with several non-trivial modifications, such as using only one Scene and not initialising characters. This also includes the character and program introduction section, which was neglected.

### Explanation

```
,.Puck,.Ajax,.Act I:.Scene I:.     # Introduce the characters and the play itself.
[Exeunt][Enter Puck and Ajax]      # Enter the main characters
Puck: Open heart.                  # Print Ajax's value as a number
      You is the sum ofyou a cat.  # And increment it
Ajax: You is twice the sum ofa big big cat a cat.      # Set Puck to 2*(8+2)=10
      Speak mind!                  # Print as a character (a newline)
      You is the square ofyou.     # Square the value to 100
      Is I nicer you?              # Compare the value against Ajax's
      If notlet usAct I.           # And loop if the value is <= 100

```
> 3 votes

# Answer
# JavaScript (V8), ~~52~~ 39 bytes

```
for(i=0;!print(i)>=~-(''+i++).length;);

```

Try it online!

Thanks Jo king

# Original version :

# JavaScript (V8), ~~52~~ 48 bytes

```
for(i=0;i<=(c="    ".length)*-~c*-~c;)print(i++)

```

Try it online!

Not the shortest by any margin

# Explanation :

```
for(i = 0; // simple for loop
    i <= (c="    ".length)*~-c*~-c;
        // c = "    ".length ---> 4
        // * -~c * -~c       ---> -~c => 5 => 4 * * 5 * 5 ==> 100
        ;)print(i++)          ---> end for loop and print i, then increment by 1

```

# Alternately :

# JavaScript (V8), 47 bytes

```
_=>[...Array((c="    ".length)*-~c*-~c).keys()]

```

Try it online!

That prints up to 99 for 51 bytes,

```
_=>[...Array((c="     ".length)**~-~-c-c*c).keys()]

```

Prints upto 100 but byte count is 54.
> 3 votes

# Answer
# 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!]

```
> 3 votes

# Answer
# Piet \+ ascii-piet, 39 bytes (7×6=42 codels)

Slightly cheating to use a language which isn't even text, but even the ascii-piet encoding of it contains no digits.

```
tlrtmE rraaD ? aaAdd? aAd ?aAk   Aletrq

```

This ascii-piet compiles into this piet program:

Try Piet online!
> 3 votes

# Answer
# Vyxal, 3 bytes

```
₁ɾ⁋

```

Try it Online!

I guess so.
> 3 votes

# Answer
# Trilangle, 26 bytes

```
'0.vj..!"/@.)e.,>-./.._..'

```

Test it in the online interpreter!

Trilangle is a 2-D language inspired by Hexagony. It has its own instruction set, and two major differences when it comes to code/memory layout:

* The bounding box of the code is a triangle rather than a hexagon
* Memory is stored in a stack\* rather than a grid.

The memory structure isn't a pure stack, as it's possible to look (but not write) arbitrarily far down the stack. This feature makes it Turing-complete.

## Explanation

When unwrapped into the triangular grid, this code is:

```
      '
     0 .
    v j .
   . ! " /
  @ . ) e .
 , > - . / .
. _ . . ' . .

```

The IP starts at the north corner, moving southwest.

For lack of a fancy tool, have a diagram I made in paint:

The IP initially follows the red path, hitting the following instructions:

* `'0`: Push the number `0` to the stack
* `v`: Change the direction of control flow
* `!`: Print the number on top of the stack in decimal
* `)`: Increment the top of the stack
* `.`: No-op
* `'`: Part of a "push" instruction

After hitting the partial "push" instruction, the IP walks off the edge of the board and continues one diagonal to its left -- on the green path.

* `0`: The rest of the push instruction; pushes another `0`
* `j`: The indexing operator. The stack now contains two copies of the same number (1 more than the value that was printed last).
* `"e`: Push the value of the character 'e' (101 in decimal)
* `/`: Changes the direction of control flow
* `.`: No-op again
* `-`: Subtract the two values on top of the stack. If the last value printed was *n*, the stack now contains \[*n*+1, *n*-100\].
* `>`: Branch. If the value on top of the stack is positive or zero, it takes the yellow path; if the value is negative, it takes the blue path.

On the yellow path, the next instruction is `@`, which terminates the program. Continuing on the blue path, the instructions are:

* `_`: Changes the direction of control flow
* `,`: Pop from the stack

\[Run off the edge and continue on the magenta path\]
* A few more NOPs
* `/`: Changes the direction of control flow again. It runs off the edge and continues at `v`, where it merges with the red path.

## Is this optimal?

I'm not sure. Given the number of NOPs in the code I'd be unsurprised if this can be reduced, but I don't think I can make the entire triangle smaller (reducing its side length to 6) without substantially restructuring it.
> 3 votes

# Answer
# makina, 58 bytes

```
v<<<<<<LtIaaa;
>Pu>>>?= LCS
UC>n0;H>>^>>n0;
     UPJ >JC>U

```

I AM BUTTER FEED ME BOT

*I'm a bot. This answer was posted by a human to get me enough reputation to use chat.*
> 3 votes

# Answer
# Pyth, 9, 8, 5 bytes

@hakr46's solution

```
Uh*TT

```

Try it online!

---

original:

```
U+*TT^Z

```

Try it online!

Outputs a list. If the separator must be a single character, 11 bytes 6 bytes

My first golf. Pretty happy about it! Makes use of the fact that anything to the power of 0 is 1.

-3/5 bytes thanks to @hakr46 :D
> 2 votes

# Answer
# Clojure, 24 bytes

```
(apply pr(range(int\e)))

```

Try it online!

If it is acceptable that output is wrapped in parentheses, then we can remove `apply` for -6 bytes.
> 2 votes

# Answer
# CJam, 6 bytes

```
'ei,:p

```

Try it online!

### How it works

```
'e    e# Push character "e" (which has code point 101)
i     e# Convert to integer. Gives 101
,     e# Range (non-inclusive, starting at 0). Gives [0 1 2 ... 100]
:p    e# For each entry: print with newline

```
> 2 votes

# Answer
# F# (.NET Core), 35 bytes

```
Seq.iter(printfn"%A"){0..(int 'd')}

```

Try it online!

(Too bad it wasn't only to 99, could have gotten rid of the `Seq.iter` due to printing truncation...)
> 2 votes

# Answer
# BRASCA, 9 bytes

```
Hr,n[lon]

```

Try it online!

## Explanation

```
Hr         - Push range(0,100)
  ,        - Reverse stack
   n       - Print the 0
    [   ]  - While not zero:
     lon   -    Print a newline and the next number

```
> 2 votes

# Answer
# Alice, 17 bytes

```
aa*r\
 @Q
&d\
 O

```

Try it online!

**Explanation:**

```
a       Push 10
 a      Push 10
  *     Pop x. Pop y. Push x * y
   r    Pop n. Push all integers from 0 to n, inclusive
    \   Switch to Ordinal mode. Redirect command flow to the southeast
        Command flow hits the boundary of the grid and is reflected to the southwest
   Q    Reverse the order of the stack
  \     Switch to Cardinal mode. Redirect command flow to the west
 d      Push the number of elements currently on the stack
&       Pop n. Add n to the iterator queue
        Command flow hits the boundary of the grid and wraps
  \     Switch to Ordinal mode. Redirect command flow to the southwest
 O      Pop s. Print s as a string followed by a newline
          (Gets executed the number of times stored on the top of the iterator queue)
        Command flow hits the boundary of the grid and reflects to the northwest
&       Pop s. Add s to the iterator queue
          (Everything between here and the end of the program is just the command flow
          bouncing around until it reaches the @)
        Command flow hits the boundary of the grid and reflects to the northeast
  *     Pop b. Pop a. Push the concatenation of a and b
          (Executes 0 times because & added an empty string to the iterator queue)
        Command flow hits the boundary of the grid and reflects to the southeast
   Q    Reverse the order of the stack
        Command flow hits the boundary of the grid and reflects to the southwest
        Command flow hits the boundary of the grid and reflects to the northwest
  \     Switch to Cardinal mode. Redirect command flow to the south
        Command flow hits the boundary of the grid and wraps
  *     Pop x. Pop y. Push x * y
  @     Terminate the program

```
> 2 votes

# Answer
# C (gcc), 35 bytes

```
f(i){printf("%d ",i)&'#'?f(++i):0;}

```

Try it online!

Let's go recursively!
> 2 votes

# Answer
# Wolfram Language (Mathematica), 29 bytes

included more for the amusing built-in than the byte count, though this would be something like 9 bytes in the hypothetical mthmca golfing language.

```
Range[0,FromRomanNumeral@"C"]

```

Try it online!

And similar, but longer

```
Range[0, Interpreter["SemanticNumber"]@"hundred"]

```
> 2 votes

# Answer
# PHP, 29 bytes

```
<?=join(',',range(0,ord(d)));

```

**Explanation**

```
ord(d) // return integer value of ASCII character 'd'
range  // create array from A to B, inclusive
join   // glue array values together using comma as separator
<?=    // output

```

Try it online!
> 2 votes

# Answer
# Java (JDK), 71 bytes

```
v->java.util.stream.IntStream.range(0,'e').forEach(System.out::println)

```

Try it online!
> 2 votes

# Answer
# Tcl, 38 bytes

```
puts 0
time {puts [incr i]} [incr u]00

```

Try it online!
> 2 votes

# Answer
# T-SQL, ~~65~~ 64 bytes

```
SELECT number FROM spt_values WHERE number<ASCII('e')AND'P'=type

```

The `master` database on any SQL server contains a system table called `spt_values` that (among other things) contain the numbers 0 to 2047. To cap the output I used `ASCII('e')`, which is 101.

Let me know if you know of a shorter way to generate the number 100 or 101.
> 2 votes

# Answer
## Atari 600XL, 22 bytes

Sorry I overread that it's not allowed to use the characters 1-9.

I think it is really stupid to say my language can this is a shorter way, because every language today contains more than a bunch of foreign frameworks. IMHO this "bytes" should be added to the real bytes you need to print values from 0 to 100 on the screen. Therefore a good old Atari 600XL with 16kib of RAM only need: 22 bytes. No other Software is need everything is build in.

Switch the hardware on, wait 2-3sec and type: f.a=0toasc("d"):?a:n.a

'f.' is an allowed shortcut for 'for' and 'n.' is a shortcut for 'next'

Maybe the C64 need also such less bytes.

Everything else need megabytes of extra hidden bytes.

JM2C
> 2 votes

# Answer
# Erlang (escript), 42 bytes

```

main([])->io:write(lists:seq(0,hd("d"))).

```

Try it online!
> 2 votes

# Answer
# BASIC, 32 27 bytes

```
for a=0 to asc("d"):?a:next

```

Try it online!

while(a\<asc("e")):?a:a=a+!0:wend

Of course, a FOR loop is shorter than using WHILE. Thanks Lars for your example.

My earlier (apparently invalid) attempt, which got downvoted for not stopping at 100:

```
0 ?a:a=a+!0:goto 0

```

Try it online!

I'll leave it here for completeness - only 18 bytes though.

Now this is not going to beat some volcano in New Zealand either... that said, it would work on 8-bit computers where the entire language interpreter was on a ROM that might be 2-16 KILObytes for the whole thing. Every bytes counted (like code golf) - there certainly wasn't space to add topographical data for the developer's favourite mountain range.
> 2 votes

# Answer
# JavaScript Browser, 37 characters

```
alert([...Array(0xB0F-0xAAA).keys()])

```

## But Arnaulds(https://codegolf.stackexchange.com/users/58563/arnauld) idea would be the faster way for browser js too (28)

```
for(n=0;n+n<0xCA;)alert(n++)

```
> 2 votes

# Answer
# Excel, ~~23~~ ~~22~~ 23 bytes

```
=SEQUENCE(CODE("e"),,0)

```

Spreadsheet

## Invalid Change

```
=SEQUENCE(CODE("e"))-1

```
> 2 votes

# Answer
# Forth, 30 bytes

```
char e false [do] [i] . [loop]

```

Try it online!

commented:

```
char e \ ascii value 101
false \ 0
[do] \ loop a fixed number of times
[i] \ retrieve the iterator value
. \ print the top of the stack as a number, followed by a space
[loop] \ end of loop

```
> 2 votes

# Answer
# Forth, 26 bytes

```
char e 0 [do] [i] . [loop]

```

Try it online!

commented:

```
char e \ ascii value 101
0
[do] \ loop a fixed number of times
[i] \ retrieve the iterator value
. \ print the top of the stack as a number, followed by a space
[loop] \ end of loop

```
> 2 votes

# Answer
# CSASM v2.2.1.2, 143 bytes

```
func main:
.local a : obj
push 0
pop a
inc a
inc a
push a
inc a
inc a
inc a
push a
mul
dup
mul
pop a
lda 0
.lbl a
inc $a
push $a
dup
print.n
push a
sub
brtrue a
ret
end

```

**Commented and ungolfed:**

```
func main:
    .local onehundred : obj

    ; Calculate 100
    push 0
    pop onehundred
    inc onehundred
    inc onehundred
    push onehundred
    ; Stack: [ 2 ]
    inc onehundred
    inc onehundred
    inc onehundred
    push onehundred
    ; Stack: [ 2, 5 ]
    mul
    ; Stack: [ 10 ]
    dup
    ; Stack: [ 10, 10 ]
    mul
    ; Stack: [ 100 ]
    pop onehundred

    lda 0
    .lbl loop
        ; Print $a
        inc $a
        push $a
        dup
        print.n

        ; Zero is falsy.  Check if $a - 100 == 0
        push onehundred
        sub
        brtrue loop
    ret
end

```
> 2 votes

# Answer
# Kotlin, 42 bytes

It ain't much but it's honest work

```
fun main(){for(i in 0..0xa*0xa)println(i)}

```

Try it online!
> 2 votes

# Answer
# Pyth, 4 bytes

```
UC\e

```

Try it online!
Surprised myself by topping the previous Pyth's top score of 5 bytes. Creates a range from 0-101 (char code of 'e' = 101)
> 2 votes

# Answer
# Vim, 16 bytes

```
i0<Esc><C-a>s<C-r>=r    <C-r>"0<C-r>")

```

Try it online!

Explanation:

```
i0<Esc>                                 # Insert `0`
       <C-a>                            # Increment
            s                           # Delete into register " and Insert
             <C-r>=                     # Start expression
                   r                    # Tab-autocomplete `range(`
                        <C-r>"          # 1
                              0         # 0
                               <C-r>"   # 1
                                     )  # Full expression is `range(101)`
                                        # Insert the range [0..101)

```

Alternatively (and more interesting, imo):

# Vim, 18 bytes

```
iYp<C-v><C-a>0<Esc>d^@=!0
00@-

```

Try it online!

Explanation:

```
iYp<C-v><C-a>0<Esc>        # Insert `Yp<C-a>0`
                   d^      # Delete `Yp<C-a>`
  @-                       # Execute `Yp<C-a>`... times
                     @=!0  #                  1
00                         #                   00

```
> 2 votes

# Answer
# Java 106 bytes

```
class p {public static void main(String[] args){int i='A'/'A';while(i<=(int)'d')System.out.println(i++);}}}}

```

*TIO*
> 2 votes

# Answer
# Oracle SQL, 56 bytes

```
select level-cos(0)from dual connect by level<ascii('f')

```

Try it online!
> 2 votes

# Answer
# !@#$%^&\*()\_+, 13 bytes

```
e($!#^$_^_
@)

```

Try it online!

Explaination:

```
e($!#^$_^_
@)

e            Pushes 101 onto the stack
 (           While
  $          Swap
   !#        Output number without popping and newline
     ^       Top of stack = Top of stack + 1
      $      Swap
       _^_   Top of stack = Top of stack - 1
<newline>    Push 10
@            Output top of stack as ASCII and pop
 )           Close while

```
> 2 votes

# Answer
# JavaScript (V8), 30 bytes

```
for(i=0;+!print(i)+'00'-i++;);

```

Try it online!

Jo king saves more bytes that I can count :)
> 2 votes

# Answer
# Labyrinth, 18 bytes

```
0) @
0 \(
)#":
 (!

```

Try it online!

Push 101 (`)` is increment and `0` is "append zero" command), and run "print stack height - 1, dup, decrement" until the top becomes zero.

# Labyrinth, 19 bytes

```
0)
0
)}:!
 " \
@({)

```

Try it online!

Keep track of two values `a=0` and `b=101`, print `a` and increment and decrement `b` until `b` becomes zero.
> 2 votes

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

```
> 2 votes

# Answer
# Pure Bash, 34 + 1 = 35 bytes

Filename must be `x`; this is for extra one byte.

```
echo $[x++]
a=x
((x>${#a}00))||. x

```

Try it online!
> 2 votes

# Answer
# Lua (29 bytes)

```
for i=0,0xA..0 do print(i)end
```
> 2 votes

# Answer
# HBL, 2 bytes

```
00'%

```

Try it here!

### Explanation

```
0     Inclusive range
 0    from 0
  '%  to 100

```
> 2 votes

# Answer
# Julia, 19 bytes

```
;echo $(0:Int('d'))

```

This only works in the REPL as the `;` it used to enter the shell mode.

In a normal Julia file, this

```
println.(0:Int('d'))

```

works and is 20 bytes long.

If we allow the values to be printed as part of an error message, this

```
;$(0:Int('d'))

```

does it in 14.

If the printing isn't required (as Julia shows the value of the last line in the terminal) then, `[0:Int('d')...]` only has 15 bytes.

edit: reverted to my first solution as the improved one had a '2' in it. Oups
> 2 votes

# Answer
# \>\<\>, 11 bytes

```
lnaol:aa*(%

```

Try it online!

Terminates by error.
> 2 votes

# Answer
# Rust, 49 bytes

`(0..'e' as usize).for_each(|x| print!("{} ",x));`

* `'e' as usize` casts literal `'e'` to its Unicode number
* Creates a Range and then for each of the elements in the range, prints the elements.
> 2 votes

# Answer
# Itr, 10 bytes

```
'eMºM»£'
¥

```

online interpreter

4 bytes (`'eMº`) if surrounding the output with brackets is allowed

## Explanation

```
'e          ; the literal 'e' (ascii 101)
  Mº        ; unwrap string,and convert to 0-based range
    M»      ; for every element of the range
      £     ; print the element
       '
        ¥   ; print a newline

```
> 2 votes

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

```
> 2 votes

# Answer
# Nibbles, 1.5 bytes (3 nibbles)

```
:`,

```

Attempt This Online!

```
:`,     # full program
:`,$$   # with implicit args shown;
:       # join
 `,     #   range from 0 to value minus 1:
   $    #     value = 100
        #     (if no input is given to a nibbles program,
        #     the variable '$' is assigned a value of 100)
    $   #   to 100

```

Note that the program `:`,` is the human-readable form of the code (incidentally not containing the characters `1`-`9`).
The actual 1.5-byte Nibbles program consists of the nibbles `0111`, `1011` and `0111`. By default, these are saved with a 'padding' nibble of `0110` to make-up a whole number of bytes in operating systems that cannot store fractional-byte files. This could be interpreted as a 2-character program `{v`: note that this does not contain the characters `1`-`9` either.
> 2 votes

# Answer
# Javascript (Browser), ~~53~~ ~~46~~ ~~37~~ 33 bytes

```
for(n=0;++n<+atob`MTAx`;)alert(n)

```

-15 bytes thanks to @EliteDaMyth
> 1 votes

# Answer
# VBScript, 33 bytes

```
for i=0 to asc("d")
msgbox i
Next

```

Competitive answer in VBScript!
> 1 votes

# Answer
# , 12 bytes

```
a.i.@i.'e'"_

```

Try it online!
> 1 votes

# Answer
# Charcoal, ~~7~~ 5 bytes

```
ＩＥ℅eι

```

Try it online! Link is to verbose version of code. Explanation:

```
   e    Literal string `e`
  ℅     ASCII code i.e. 101
 Ｅ      Map over implicit range
    ι   Current value
Ｉ       Cast to string
        Implicitly print

```
> 1 votes

# Answer
# C# (.NET Core), 56 bytes

```
for(int i=0;i<=(0xb0e-0xaaa);i++){Console.WriteLine(i);}

```

Try it online!
> 1 votes

# Answer
# Nim, 26 bytes

```
for i in 0..'d'.ord:echo i

```

Try it online!
> 1 votes

# Answer
# Tcl, 46 bytes

```
set i 0
while \$i<[incr u]0$u {puts $i
incr i}

```

Try it online!
> 1 votes

# Answer
# 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
> 1 votes

# Answer
# ///, ~~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!
> 1 votes

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

```
> 1 votes

# Answer
# Elixir, ~~42~~ 28 bytes

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

```

Try it online!
> 1 votes

# Answer
# Japt, 2 bytes

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

```
> 1 votes

# Answer
# 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!
> 1 votes

# Answer
# 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.
> 1 votes

# Answer
# 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)
> 1 votes

# Answer
# 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
> 1 votes

# Answer
# 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.
> 1 votes

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

```
> 1 votes

# Answer
# 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\\$.
> 1 votes

# Answer
# GFortran, 29 bytes

try it online!

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

```

Similar to this.
> 1 votes

# Answer
# 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)

```
> 1 votes

# Answer
# 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!
> 1 votes

# Answer
# Python 3; 46 Bytes

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

```
> 1 votes

# Answer
# 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!
> 1 votes

# Answer
# 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.
> 1 votes

# Answer
# \>\<\>, 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

```
> 1 votes

# Answer
# 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.

```
> 1 votes

# Answer
# 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!
> 1 votes

# Answer
# 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!
> 1 votes

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

```
> 1 votes

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

```
> 1 votes

# Answer
# Hebigo, 25 bytes

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

```
> 1 votes

# Answer
## 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.
> 1 votes

# Answer
# COMMODORE 64 = 34 Bytes

With Commodore BASIC keyword abbreviations:

```
0?B:B=B-(A=.):IFB<aS(" ")*πgO

```

Or without the keyword abbreviations:

```
0 PRINTB:B=B-(A=.):IFB<ASC(" ")*πGOTO

```
> 1 votes

# Answer
6510 Assembler for C64 (159 Bytes)

```
*=$c000
a=0^0
b=a+a
    ldx #0
    txa
    dex
    stx r+b
    stx w+b
    stx z+b
    stx p+b
    stx o+b
    stx y+b
    sec
    sbc 0
    tay
    iny
    sty r+a
    sty w+a
    sty z+a
    sty p+a
    sty o+a
    sty y+a
    lda 0
    lsr
    lsr
    tay
    dey
    sty s+a
    ldy 0
    iny
    sty q+a
    sty t+a
    sty o-a
    tya
    iny
    sty p-a
    clc
    adc s+a
    sta x+a
    lda s+a
    clc
    adc s+a
    adc s+a
    tay
    iny
    iny
    sty z-a
    lda 0
    asl
    tay
    iny
    iny
    iny
    iny
    iny
    iny
    sty c+a
    ldx #0
d   txa
q   ldy #0
    sec
s   sbc #0
    bcc t
    iny
    bne s
t   cpy #0
    beq u
    sta v+1
    tya
r   jsr 0
v   lda #0
u   clc
x   adc #0
w   jsr 0
    lda #0
z   jsr 0
    inx
c   cpx #0
    bne d
    lda #0
p   jsr 0
    lda #0
o   jsr 0
y   jmp 0

```
> 1 votes

# Answer
# Vyxal `SH`, 7 bitsv2, 0.875 bytes

```
ʀ

```

Try it Online!

Another flag cocktail.

## Bitstring

```
0001101

```
> 1 votes

# Answer
# Hexagony, 19 bytes

`&!)')$0<.0.>.;/-{@_`

Try it online! or on hexagony.net

In hexagon layout:

```
   & ! )
  ' ) $ 0
 < . 0 . >
  . ; / -
   { @ _

```

Completely ungolfed:

```
    & ! ) {
   . . . . .
  . . . . . .
 & ) 0 ; 0 ' -
  . . . . . .
   . . . . .
    @ . . .

```

The solution works by maintaining an invariant at the beginning of each iteration that the current memory cell zero or negative (`current number - 100` on all iterations except the first one) and the cell to the left is the current number.

* `&!` copies current number from the cell to the left (due to the memory invarant) and prints it
* `)` increments current cell, so it will be current number for the next iteration
* `{` moves to the memory cell to the left, pointing towards two cells with zeros
* `&` copies zero from one of those cells into current cell
* `)0;` sets current cell value to 10 (ascii code for newline) and prints it
* `0` sets current cell value to 100 = 10 * 10 + 0
* `'` moves to the memory cell to the back right without turning memory pointer around, so now it points towards next number to the left and 100 to the right.
* `-` computes `next number - 100`
* Finally pointer leaves the right corner while moving to the right, so it wraps around to the top row if `next number - 100` is zero or negative, or to the bottom row otherwise where it terminates at `@`.

Golfed solution fits everything into a hexagon with side 3 by taking advantage of changing instruction pointer's direction, grid wrapping and idempotency of `-` operator.

I don't know if a solution with side 2 (7 cells) is possible, but this solutions uses 9 different operators without counting the ones that control direction, so it definitely won't fit. A more optimal side 3 solution might also be possible.
> 1 votes

# Answer
# Python 3, 33 bytes

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

```
> 0 votes

# Answer
# Batch, 56 bytes

```
@set/ax=0xb-0xa
@for /l %%b in (0,%x%,%x%00)do @echo %%b

```

-61 bytes for @Neil
> 0 votes

# Answer
# Elixir, 26 bytes

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

```

Try it online!
> 0 votes

# Answer
# C (gcc), ~~40~~ 39 bytes

Saved a byte thanks to att!!!

```
f(i){for(i=0;i<'e';)printf("%d ",i++);}

```

Try it online!
> 0 votes

# Answer
# Red, 36 bytes

```
repeat n 0 +#"e"[print n +#"a"-#"b"]

```

Try it online!
> 0 votes

# Answer
# C++ gcc, 36 bytes

Try it online!

```
main(){for(;_<'e';)cout<<_++<<'\n';}

```

Explanation : I globally initialized varible _ so its initial value is 0, now ascii value of e is 101 so I ran the loop till my variable _ is less than 'e', instead of incrementing it inside the for loop I used post increment while printing to save 1 byte

edit: I misread the question and thought 0 is also not allowed :)
> 0 votes

# Answer
# APOL, 11 bytes

`f(ô p(∈));ô`

I would've used  instead of `f`, but the rules state that you have to include 0 so the fastest route was to just print 0-99 and slap 100 at the end.
> 0 votes

# Answer
# APL, 13 bytes

```
0,⍳⍎'00',⍨⍕*0

```

\*0 ⍝ Exponential of zero = 1
⍕ ⍝ Convert to symbol '1'
'00',⍨ ⍝ Append two zeros
⍎ ⍝ Convert to number 100
⍳ ⍝ Make sequence from 1 to 100
0, ⍝ Append zero to the left
> 0 votes

# Answer
# Rust, 35 bytes

```
||for c in 0..b'e'{println!("{c}")}

```

Attempt This Online!
> 0 votes

# Answer
# C# .NET 4.7.2

With 0, 47 bytes

```
for(int i=0;i<=0xA*0xA;)Console.WriteLine(i++);

```

Without 0, 59 bytes

```
for(int i='a'-'a',j='r'-'@';i<=j+j;)Console.WriteLine(i++);

```
> 0 votes

# Answer
# Scratch, 104 bytes

Try it on Scratch!

Requires list `x` to be visible, which is the norm by default on creation.

```
define
delete all of[x v
repeat(join(<not<>>+())(join(()+())(()+(
add((item[last]of[x v])+<not<>>)to[x v

```
> 0 votes

# Answer
# Commodore C64 BASIC (THEC64, Ultimate64) 36 PETSCII characters

This can be done as a *zero liner* in direct mode in Commodore C64 BASIC. It relies on the default value of memory location zero being 47, so this will produce different results on other Commodore machines even though the have the same or a very similar interpreter, and the results will be different on the C128 in C64 mode too in some cases. The screen shot shows a proper representation, but `{PI}` is the PETSCII Pi symbol in my example, and upper case letters are shifted PETSCII graphics for keyword abbreviations.

```
x%={PI}+{PI}:fOi=.topE(.)+pE(.)+x%:?i;:nE

```
> 0 votes

# Answer
# Morsecco ~~59~~ 60 bytes

Avoiding digits is not really challenging in a language without digits, but I found it interesting which strategy would give the shortest code.

The straight forward loop takes **66** bytes:

```
. . -- - - - -.- -. --- . - .- - - . .--..-.- .- --.. --. - .- --.

```
* `. .` to `E`nter 0
* `-- -` to `M`ark the current program position
* `- - -.- -.` dup and `K`onvert to `N`umber
* `---` to `O`utput
* `. - .-` to `E`nter 1 and `A`dd
* `- - . .--..-.- .-` dup, `E`nter -101 and `A`dd
* `--.. --.` to `Z`eroskip until next `--.`
* `- .- --.` drop the unused difference and `G`o to marked position

Two more bytes can be saved by using an empty token as target for the Zeroskip (note the essential trailing space!): `. . -- - - - -.- -. --- . - .- - - . .--..-.- .- --.. - .- --.`  (**64** bytes)

Counting down is usually cheaper, but here we need to concatenate the numbers to a string to show them in the correct order (**70** bytes):

```
.    . --..-.- -- - . .- .- - - - .. -.-. .. - . --..  --.  -.- -. ---

```
* `.`  to `E`nter an empty cell on the stack as the string to build
* `. --..-.-` to `E`nter 101 so we can start the loop by decrementing
* `-- -` to `M`ark the start of the loop
* `. .- .-` decrement by `A`dding -1
* `- - - .. -.-. ..` dup, rot the string to the top and `C`oncatenate the cells with a space in between
* `- . --.. --.`  swap to get the index to the top and do a `Z`eroskip the the `G`o command that closes the loop
* `-.- -. ---` to `K`onvert the whole string to `N`umber and `O`utput

An unusual trick takes us down to **61** bytes: Counting up from -101 to 0 and directly outputting the index+101:

```
. .--..-.- -- - - - . --..-.- .- -.- -. --- . - .- --..  --.

```

I found no way to mitigate `E`ntering the 101 twice without wasting the bytes for stack juggling.

Finally, the best solution with 60 bytes turned out to be defining a recurive command (I used the undefined command `-.`):

```
.   - - --.. -. . .- .- -. -.- -. ---  . -. .-- . --..-.. -.

```
* `. [command] . -. .--` to `E`nter the command and `W`rite it to address `-.`
* `. --..-.. -.` to `E`nter 100 and call the new command
* The command itself is
    + `- - --.. -.` dup and `Z`eroskip to the self-calling `-.`
    + `. .- .-` decrement by `A`dding -1
    + `-.` call itself with the decremented value
    + `-.- -. ---` to `K`onvert to `N`umber and `O`utput. As this is done after calling itself, it is done first for the 0 case, to resorting is done automatically

e`X`ecuting the command directly from the stack `. --..-.. . - - --.. -..- . .- .- . .- -..- -.- -. --- -..-` save nine bytes for saving the command, but wastes three time the two bytes that `-..-` is longer than `-.` and five more bytes for placing `.-` on the stack to e`X`ecute `A`gain, ending in **62** bytes.

I hope this illustrates why I like morsecco as a golfing language: There are many ways to do something and a lot of tricks to discover. The pure score is not impressing, but considering that you could pack 5 characters into one byte (3^5 = 243 \< 256), *12* true bytes even beat some golfing languages!
> 0 votes

# Answer
# COMMODORE 64 (improved version) = 25 Bytes

0fOI=ATOA♥("-"):?I:nE

0 FORI=ATOASC("-"):PRINTI:NEXT

"-" = Character 100

To get the correct character in the code you have to poke it in first with POKE2061,100.
> 0 votes

# Answer
**Commodore 64 = 27 Bytes**

```
0FORO=.TO{PI}+{PI}*{PI}*{PI}*{PI}:PRINTO;:NEXT

```
> 0 votes

# Answer
# vemf, 5 bytes

```
0,│d↨

```

cancats 0 and the integers on \[1, 100\]
> 0 votes

---
Tags: code-golf, number, kolmogorov-complexity, restricted-source
---


title: Robinson Schensted correspondence

text:
# Question
Title: Robinson Schensted correspondence
\[The explanations of the algorithm come from here. I recommend reading it for a beautiful description of the algorithm.\]

This challenge is to implement the Robinson Schensted correspondence.

# Input

A permutation \\$\pi\\$ of the integers \\$\\{1, \dots, n\\}\\$.

# Output

A pair of Young Tableaux corresponding to the Robinson Schensted correspondence of \\$\pi\\$.

# Explanation

A Young Tableau of size \\$n\\$ is a two-dimensional arrangement of the numbers from \\$1\\$ to \\$n\\$, in which each number appears exactly once. They are arranged in left-justified rows, one below the other, and no row has more entries than the one above it. Also, the entries in each row are in increasing order as you read them from left to right, and the entries in each column are in increasing order as you read them from top to bottom. citation

The Robinson-Schensted algorithm takes a permutation of the numbers \\$1\\$ to \\$n\\$ and produces two Young Tableaux from it. We call these two tableaux \\$P\\$ and \\$Q\\$.

I will describe how to make \\$P\\$ first.

Given a permutation \\$a\_1, \dots, a\_n\\$, we process the numbers in the permutation from left to right. We try to insert them one after another into a growing Young tableau, making new rows where we can't do it while satisfying the conditions that the entries in each row are in increasing order as you read them from left to right.

We start with \\$a\_1\\$ and place it in the top left. We then try to place \\$a\_2\\$ to its right. If \\$a\_2 \< a\_1\\$ then we make a new row, place \\$a\_1\\$ in the new row on the left and place \\$a\_2\\$ in the top left. If \\$a\_2 \> a\_1\\$ then we simply append it to the first row. Now consider \\$a\_3\\$. If it is larger than all the numbers in the first row we simply append it to the first row. If not, we find the first number in the first row that is larger than it and replace that number with \\$a\_3\\$. We now take the number that we replaced, and we insert it into the second row, in the same way as before. This may cause a number to be "bumped" out of the second row and inserted into the third row. We keep going in the same way all through the permutation, always inserting the next number from our permutation starting at the first row of the tableau.

\\$Q\\$ has the same shape as \\$P\\$, but we just number the boxes by the step at which that box appeared in \\$P\\$.

# Examples

```
pi = [2 1 3]
P = [[1, 3], [2]]
Q = [[1, 3], [2]]
pi = [1 3 2 4]
P = [[1, 2, 4], [3]]
Q = [[1, 2, 4], [3]]
pi = [5 3 4 1 2]
P = [[1, 2], [3, 4], [5]]
Q = [[1, 3], [2, 5], [4]]
pi = [1 5 6 4 2 3]
P = [[1, 2, 3], [4, 6], [5]]
Q = [[1, 2, 3], [4, 6], [5]]
pi = [4 2 6 5 7 3 1]
P = [[1, 3, 7], [2, 5], [4], [6]]
Q = [[1, 3, 5], [2, 4], [6], [7]]

```

# Answer
> 4 votes
# Charcoal, 66 bytes

```
≔Ｅθ⟦⟧ηＦθ«≔⁰ζＷΦ§ηζ›λι«§≔§ηζ⌕§ηζ⌊κι≔⌊κι≦⊕ζ»⊞§ηζι⊞υζ»Ｅ⟦η⊕Ｅθ⌕Ａυκ⟧⭆¹Φιν

```

Try it online! Link is to verbose version of code. Explanation:

```
≔Ｅθ⟦⟧η

```

Create `P` with an array for each entry, just in case.

```
Ｆθ«

```

Loop over the input list.

```
≔⁰ζ

```

Start at the first array of `P`.

```
ＷΦ§ηζ›λι«

```

Repeat while the current array of `P` has elements greater than the current value.

```
§≔§ηζ⌕§ηζ⌊κι

```

Replace the next greater element with the current value.

```
≔⌊κι

```

Replace the current value with the next greater element.

```
≦⊕ζ

```

Move to the next array of `P`.

```
»⊞§ηζι

```

Append the current value to the current array of `P`.

```
⊞υζ

```

Keep a record of the insertion indices.

```
»Ｅ⟦η⊕Ｅθ⌕Ａυκ⟧⭆¹Φιν

```

Build `Q` from the list of insertion indices, then trim trailing empty elements from both `P` and `Q` and pretty-print them at a cost of 1 byte (the default output format isn't terribly readable).

# Answer
> 4 votes
# JavaScript (ES12), 124 bytes

Returns `[P, Q]`.

```
a=>a.map(g=v=>(p=P[y]||=[]).some((V,k)=>V>v?p[n=V,k]=v:0)?g(n,y++):y=(Q[y]||=[]).push(++j)^p.push(v),y=j=0,Q=[],P=[])&&[P,Q]

```

Attempt This Online!

### Commented

```
a =>                // a[] = input array
a.map(g =           // using a recursive callback function g,
  v =>              // for each value v in a[]:
  ( p =             //   p[] is the entry at position
      P[y] ||= []   //   y in P[] (initialized to [] if undefined)
  )                 //
  .some((V, k) =>   //   for each value V at index k in p[]:
    V > v ?         //     if V is greater than v:
      p[n = V, k]   //       save V in n
      = v           //       set p[k] to v and trigger the some()
    :               //     else:
      0             //       keep searching
  )                 //   end of some()
  ?                 //   if found:
    g(n, y++)       //     do a recursive call with v = n
                    //     and y incremented
  :                 //   else:
    y =             //     save in y:
      (Q[y] ||= []) //       initialize Q[y] to [] if undefined
      .push(++j) ^  //       increment j and push it in Q[y]
      p.push(v),    //       push v in p[]
                    //     p[] and Q[y] have the same length L,
                    //     so this resets y to (L xor L) == 0
  y = j = 0,        //   start with y = 0 and j = 0
  Q = [],           //   initialize Q[]
  P = []            //   initialize P[]
) && [ P, Q ]       // end of map(); return [ P, Q ]

```

# Answer
> 3 votes
# , 115 bytes

```
\(x){P=Q=!x%o%x;for(i in x){r=1;while(i<-P[r,w<-which.min(P[r,]%in%1:i)]-!(P[r,w]=i))r=r+1;Q[r,w]=F=F+1};list(P,Q)}

```

Attempt This Online!

For an input vector of length \\$n\\$, this returns a pair of \\$n \times n\\$ matrices initialized with zeros and the actual content of tableaux filled in. I hope, that's an acceptable output format.

### Explanation

```
\(x) {
  P=Q=!x%o%x                    # Initialize the matrices
  for (i in x) {                # Loop through the elements
    r=1                         # Start at row 1. We can't abuse built-in T here
                                # as it has to be reset on each iteration
    while ({
      w=which.min(P[r,]%in%1:i) # Find the first element in the current row that is >i or 0
      i=P[r,w]-!(P[r,w]=i)      # Swap the found element with i
    i})                         # While we are not on 0 (empty space)
      r=r+1                     # Go to the next row
    Q[r,w]=F=F+1                # When finished, increase the turn number and store it in Q
  }
  list(P,Q)                     #... and return
}

```

# Answer
> 2 votes
# Python3, 559 bytes

```
E=enumerate
from itertools import*
Z=zip_longest
W=lambda x:[[*filter(None,i)]for i in x]
V=lambda X:all(all(x[i]<x[i+1]for i in range(len(x)-1))for x in X)
def U(p,a):p[0]+=[a]
def G(P,a,I):P[I-1]=[*P[I-1][:len(P[I])],P[I][-1],*P[I-1][len(P[I]):]];P[I]=[a,*P[I][:-1]]
def f(l):
 p,q=[[l.pop(0)]],[[1]]
 for i,a in E(l,2):
  F=1
  for I,v in E(p[0]):
   if v>a:
    F=0;P=W(Z(*p));Q=W(Z(*q));P[I]=[a,*P[I]];Q[I]=[i,*Q[I]]
    if V(W(Z(*P)))==0:P[I]=P[I][1:];Q[I]=Q[I][:-1];G(P,a,I);G(Q,i,I)
    p=W(Z(*P));q=W(Z(*Q))
    break
  if F:U(p,a);U(q,i)
 return p,q

```

Try it online!

# Answer
> 1 votes
# , 60 bytes

```
g=.<`(/:~(-.;$:@])&;2<@-./\_"+]F:.(]`I.`[}~)])@.(1<#)
,:&g/:

```

Attempt This Online! (*Note: code won't actually run because ATO's J isn't new enough. See below for how to run locally.*)

## The idea

Consider input `4 2 6 5 7 3 1`:

* Fold forward through the input, collecting results. Seed the fold with a list of infinity repeated `n` times, where `n` is the input length. The fold logic is...
* At each step, find the "insert before" point for the next element (where you'd need to insert it to maintain ascending order), but instead of inserting, overwrite the list at that position. For our example input, the result would be:

```
4 _ _ _ _ _ _
2 _ _ _ _ _ _
2 6 _ _ _ _ _
2 5 _ _ _ _ _
2 5 7 _ _ _ _
2 3 7 _ _ _ _
1 3 7 _ _ _ _

```
* Notice the final row `1 3 7` already contains the first row of the `P` Young tableaux. We also need the 4 evicted elements, in order of eviction, to call the function recursively and so build the entire tableaux.
* To find them, take the set difference of every pair of rows. This difference will be empty when the fold appends an element, and it will be the evicted element when the fold overwrites:

```
┌─┬┬─┬┬─┬─┐
│4││6││5│2│
└─┴┴─┴┴─┴─┘

```
* Next, append to `1 3 7` the result of running the above procedure recursively on `4 6 5 2`. This gives us the `P` tableaux.
* Finally, to get the `Q` tableaux, we do everything again on the "grade up" of the input, rather than the input itself.

### Alternate way to find evicted elements

It's worth pointing out this alternate approach to finding the evicted elements from the cumulative fold result, since it may help submissions in other languages.

* Take the fold result above, remove the infinity placeholders, and flatten it:

```
4 2 2 6 2 5 2 5 7 2 3 7 1 3 7

```
* Remove the final row elements `1 3 7`:

```
4 2 2 6 2 5 2 5 2

```
* Take the uniq, but start at the right side instead of the left:

```
2 5 6 4

```

This is exactly the reverse of what we need. So uniq "under" reverse `~.&.|.` produces the evicted elements in the correct order:

```
4 6 5 2

```

The full J code for this approach is:

```
g=.<`([:({:,~.&.|.&;$:@-.;@{:)_"+<F:.(]`I.`[}~)])@.(1<#)
,:&g/:

```

## Local tests

These tests require J 9.4.2.

The code expects 0-indexed input and produces 0-indexed output. However, to keep the test readable, we do pre- and post-processing below so that the actual input/output is 1-indexed.

```
g=.<`(/:~(-.;$:@])&;2<@-./\_"+]F:.(]`I.`[}~)])@.(1<#)
f=.,:&g/:

>:L:0 f <: 5 3 4 1 2
>:L:0 f <: 1 5 6 4 2 3
>:L:0 f <: 4 2 6 5 7 3 1
>:L:0 f <: 1 2 3 4
>:L:0 f <: 4 3 2 1

```

Running the above produces:

```
  >:L:0 f <: 5 3 4 1 2
┌───┬───┬─┐
│1 2│3 4│5│
├───┼───┼─┤
│1 3│2 5│4│
└───┴───┴─┘
  >:L:0 f <: 1 5 6 4 2 3
┌─────┬───┬─┐
│1 2 3│4 6│5│
├─────┼───┼─┤
│1 2 3│4 6│5│
└─────┴───┴─┘
  >:L:0 f <: 4 2 6 5 7 3 1
┌─────┬───┬─┬─┐
│1 3 7│2 5│4│6│
├─────┼───┼─┼─┤
│1 3 5│2 4│6│7│
└─────┴───┴─┴─┘
  >:L:0 f <: 1 2 3 4
┌───────┬─┐
│1 2 3 4│_│
├───────┼─┤
│1 2 3 4│_│
└───────┴─┘
  >:L:0 f <: 4 3 2 1
┌─┬─┬─┬─┐
│1│2│3│4│
├─┼─┼─┼─┤
│1│2│3│4│
└─┴─┴─┴─┘

```

Note the 2nd to last test case contains an extraneous blank, but this is allowed.

# Answer
> 1 votes
# Haskell, 177 bytes

```
import Data.List
h([],_,n)x=([[x]],[[n]],n+1)
h(p:w,q:z,n)x|(t,y:d)<-span(x>)p,(w,z,m)<-h(w,z,n)y=((t++x:d):w,q:z,m)
h(p:w,q:z,n)x=((p++[x]):w,(q++[n]):z,n+1)
f=foldl h([],[],1)

```

Attempt This Online!

---
Tags: code-golf, combinatorics
---


title: Tips for Golfing in Vyxal

text:
# Question
Title: Tips for Golfing in Vyxal
Vyxal is a golfing language that has 500+ different commands (achieved through overloads), and is a known beater of Jelly, 05AB1E and most golfing languages.

Henceforth, it seems like a good idea to share some of the tips and tricks of the industry used to get terse programs in Vyxal.

One tip per answer, and no stupid tips like "oh remove comments and whitespace".

# Answer
> 10 votes
# Brackets/Structures autocomplete

*Totally not stolen from Tips for golfing in keg because Vyxal totally isn't supposed to be keg but 69 times better*

If you have a structure (e.g. if/for/while/function/lambda) that has nothing after it, and EOF follows, you can remove the closing bracket/semicolon. Note that this only applies if you are submitting a full program.

For example:

```
9(0,)

```

Can be shortened to:

```
9(0,

```

And:

```
{:1=[1,]}

```

Can be shortened to:

```
{:1=[1,

```

# Answer
> 8 votes
# Compress your strings and numbers

Nobody likes long strings. And nobody likes long numbers either. Luckily there's two ways of compressing strings and one way to compress numbers.

## Dictionary Compression

Fun fact: Vyxal has access to a roughly 20k word "dictionary" (read: a list of words) which can be used to shorten strings with a) common English words or b) common 3 letter combinations.

To access the words in this dictionary, you need to get the String Compression Code (SCC) of the word and place it inside a normal string (the backtick ones). String Compression Code is simply a way of saying "the base 10 index of the word within the dictionary list converted to a bijective base-1611".

You can get the SCC of a word by using `øD`. For example:

```
`Hello`øD

```

(Try it Online!)

Tells you the SCC for `Hello` is `ƈṡ`. However, `øD` will also return the dictionary compression of a given string:

```
`Hello, World!`øD

```

Is turned into `ƈṡ, ƛ€!`.

`øD` is fully optimised and will always give you the shortest possible result. For example, compressing `abcdef` will return `ėġḣ²`.

## Base-255 Compression

But what if your string is a bunch of random letters that aren't in the dictionary at all? `øD` becomes useless for obvious reasons. In this case, you would use `«` delimited strings.

These strings take everything inside of them, converts it from a bijective base-255 (the vyxal codepage minus `«`) to base 10. It then converts that result to a bijective base-27 (the lower case alphabet plus space). **Important: only stings containing lower case letters and spaces can be Base255 compressed**3.

To get the Base255 compression of a string, you can use `øc`:

```
`ahroebeodbslnwksozlzbeoxbeodbsonwkdbdi`øc

```

Tells you that the compression is `«∧pŀQb⟨ż₄∑ṄḞḊjẎɾ71(⁼~∇Ċβ«`.

## But what about numbers???

`»` strings have got you covered. `øC` will take an integer and return it converted to a bijective base-255 (the vyxal code page minus `»`:

```
69694204206969øC

```

Gives you `»A⟩¾Ǐø7»`

1: The bijective base 161 is simply the vyxal code page minus all printable ascii. This is so that SCCs can be embedded inside strings without creating a new string type.

2: Yeah, SCCs don't need to be surrounded by spaces - they can be inside ascii (`a÷×b`) or even next to each other (`£÷¬¶`). This is very intentional.

3: I originally allowed for upper and lower case inside base 255 strings, but found that strings are usually shorter when only allowing lower case.

# Answer
> 8 votes
# Use  and  for certain length checks

Say you have a string and you want to check whether its length is greater than 1, and the output only needs to be truthy or falsy.

You could go `L1>` for three bytes. Or, you could go  for 1 byte.

Ḣ slices off the first character of a string and returns the rest, so running on a length 1 string returns an empty string, which is falsy; on a length ≥2 string, it returns a truthy non-empty string.

What about length \>2? Just use `ḢḢ`, with the same logic as before, and still saving a byte.

Length = 1? There's literally a builtin for this -  on strings or lists returns true only if the length is 1.

Length = 2? Just combine the two (`Ḣ₃`) - if you lop off a character and that string becomes length 1, it must've been length 2.

# Answer
> 7 votes
# Use `-` as a check for recursive functions

When recursing over a deep list, `-` will return a falsy value (0 / empty string) for scalars and a truthy value (list of 0) for lists.

Example of this in use

Note that this only works when you don't have empty lists.

does work for empty lists, returning a falsy value (empty string) for integers and a truthy value (list of lists) for lists. Thanks to lyxal for this one.

# Answer
> 6 votes
# Remember that mapping/filtering/reducing all cast numbers to ranges

Okay so say you want to apply something over the range `[1, n]` using `M`ap, `F`ilter or `R`educe (or nverse reduce/foldr). Your first instinct might be to do this:

```
ɾλ....;M # or whatever command you're using

```

This is unnecessary, as the functional programming commands all cast numbers to `range` before doing their job, so:

```
λ....;M

```

is equivalent.

"But what if my range isn't `[1, n]`, but instead `[0, n]` or `[1, n)` for example? Won't I need the corresponding range command?"

Well yes, but actually no if you use flags:

> `M` Make implicit range generation start at 0 instead of 1
>
> `m` Make implicit range generation end at n-1 instead of n

(source: flag help generated using the `-h` flag).

# Answer
> 6 votes
# Custom base decompression

When you're compressing a large amount of data with a limited charset, as in here, you can use a base-255 integer (`»...»`) and the custom base decompression function `τ`.

For example, say you want to compress this ascii-art:

```
  /
 / \
\   \
 \ / \
  /   /
 / \ /
\   \
 \ / \
  /   /
 / \ /
\   \
 \ / \
  /   /
 / \ /
\   \
 \ /
  /

```

You can just map 0 to `\`, 1 to `/`, and 2 to  to get 576780841113635223227691120919222477677740273185690732841 in base-3, which compresses to `»ɾĠ^;√⟑•ȮṙDǓ…⟩P½≠1⅛²ė"÷₆Ŀ»`.

Then, you can take out your compression guide `\/` , and append τ to turn it into base-3 with those as values.

Finally, you can split into 17 pieces (for 17 lines) and output joined by newlines - Try it Online!

# Answer
> 6 votes
# Use the nameless variable

Vyxal has variables, set by  and accessed by . But did you know that there's a nameless variable?

You can access this by just going  followed by a non-alphabetic character (it doesn't matter what, and that will still be run). Ditto with setting.

It works in for loops - try `4(|←,)`.

In other words, it's an extra register that can easily save you a couple of bytes.

# Answer
> 5 votes
# Use the multi-element lambdas if your lambda body is 1-3 bytes

Say you have the following:

```
λǐṅ;Ẋ

```

You can turn this into

```
‡ǐṅẊ

```

Because  combines the next two elements (built-ins) into a single lambda.  is for 1 element lambdas (good for when you want to reduce/filter/map a built-in without using `v`) and  is for 3 element lambdas.

# Answer
> 5 votes
# Use `\` for single byte strings and  for two byte strings

Sometimes you'll need a string of either one or two characters. You could do the following:

```
`A`
`AB`

```

But that has an extra backtick at the end. Instead, you can do this:

```
\A
‛AB

```

## Important

`\` pushes the next character as a string no matter what it is.  will treat it as if the next two characters were wrapped in backticks (meaning that it will dictionary uncompress a single string compression code).

# Answer
> 4 votes
# Use of filter lambda

Filter lambda (`'`) can filter out the items which are not truthy from the stack, so you don't need a lambda map and close it and then find out the Truthy indices.

This is a code using the lambda map

```
ƛǐG5>;T›

```

But if you use filter lambda, it can be shortened to

```
'ǐG5>

```

the last 3 commands are no longer needed!

# Answer
> 4 votes
# Use the register instead of a variable

Sometimes, you're using a variable over and over again, and it's using so many bytes, right? Well, if you only have 1 variable, you can use the register instead, and save a byte every time you use it!

For example, say you want to do `x * 2` and `x ^ x`. You *could* do:

```
3→x ←xd, ←x←xe,

```

This saves 3 to `x`, then retrieves it and doubles it, then retrieves twice, and exponentiates. However, `x` is being used 4 times, so that's 8 bytes in variable references alone! Using the register will shorten this code a lot:

```
3£ ¥d, ¥¥e,

```

Instead of saving to and retrieving from a variable, we're using the register, which can be accessed using only 1 byte. Anytime you're using variables, you can replace one of the variables with the register to save some bytes!

# Answer
> 4 votes
# Converting characters to numbers in

When you want to convert characters to numbers, you have to use `C`, right? Well, there's another way. You can also use `b`. The `b` command, when used on a string, will convert each character to its ASCII value, then convert that to binary. You can then use `B` to convert that back to a decimal value!

```
`EEEE` b vB

```

Try it Online!

It's not too often that you'll be able to use `bB` and not be able to use `C`, but this can be quite useful in the right circumstances.

# Answer
> 3 votes
# Utilise the Short Dictionary

*Note: This is a 2.6.x+ feature only*

Newer versions of Vyxal have a neat little feature where 1 character SCCs are indexed into a special "short" dictionary of overlyspecialised "words". Here's a list of all the current entries:

```
\d+ λ
-?\d+ ƛ
\d+\.\d+ ¬
-?\d+(\.\d*)? ∧
[A-Za-z0-9\.,;:!?()"'%\-]+ ⟑
^\S+@\S+$ ∨
[A-Za-z0-9] ⟇
[A-Za-z] ÷
[a-z] ×
[A-Z] «
[0-9] »
[aeiou] °
[aeiouy] •
[bcdfghjklmnpqrstvwxyz] ß
\w+ †
.* €
[^A-z0-9] ½
[^A-Z] ∆
[^a-z] ø
[^0-9] ↔
[^aeiou] ¢
[^aeiouy] ⌐
[^bcdfghjklmnpqrstvwxyz] æ
(.+) ʀ
\W ʁ
\w ɾ
\S ɽ
\s Þ
\W+ ƈ
\w+ ∞
\S+ ¨
\s+ ↑
((www\.|(http|https|ftp|news|file)+\:\/\/)[_.a-z0-9-]+\.[a-z0-9\/_:@=.+?,##%&~-]*[^.|\'|\# |!|\(|?|,| |>|<|;|\)]) ↓
?<= ∴
?!= ∵
?<! ›
https://www.google.com ‹
https://www.google.com/query?q= ∷
https://www.duckduckgo.com ¤
https://www.duckduckgo.com/?q= ð
https://www.bing.com →
https://www.bing.com/?q= ←
https://codegolf.stackexchange.com/q/ β
https://codegolf.stackexchange.com/a/ τ
https://stackoverflow.com/q/ ȧ
https://stackoverflow.com/a/ ḃ
₁ƛ₍₃₅kF½*∑∴, ċ
:ɾ:Ẋv∑Ȯẇ ḋ
:ɾ:Ẋƛ⁽=R;Ȯẇ ė
isdo ḟ
›‹²… ġ
n't ḣ
cos(x) ḭ
sin(x) ŀ
tan(x) ṁ
acos(x) ṅ
asin(x) ȯ
atan(x) ṗ
x^2 ṙ
x^3 ṡ
x+1 ṫ
x-1 ẇ

```

So for example:

```
`β223918`

```

would return the address of this question (because `β` decompresses as `https://codegolf.stackexchange.com/q/`).

# Answer
> 3 votes
# For reverse sorting, use `µ...⌐`

If the last operation you do in a program is to sort something in a certain way then reverse it, you can save a byte by using `µ...⌐` \- take the one's complement before sorting. This only works when the preceding value is numeric.

An example.

# Answer
> 2 votes
# If there are not enough arguments on the stack, fillers will be taken based on the context

What I mean: if there are not enough arguments on the stack to perform an action, the extra arguments will come either from the input (in the "main" program), or from the function/lambda arguments. I discovered this while golfing this answer. I was trying to find a way to tie with 05AB1E, and I had this code:

```
:↵':²"Ṡ≈;i

```

I was wondering how I could remove those duplicate elements, and I decided to look at the source code. And then I found the docstring for `pop()`: `Pops (count) items from iterable. If there isn't enough items within iterable, input is used as filler`. Looking at `get_input()`, you see that it either reads the input from STDIN, or from the lambda arguments. That allowed me to shave off two bytes and my code became this:

```
↵'²"Ṡ≈;i

```

# Answer
> 2 votes
# Use string interpolation

Apparently automatic string interpolation (`Π`) has been incorporated into Vyxal from v2.13.3 onwards.
When used inside a string, `Π` pops a value from the stack and interpolates it into the string.

For example:

```
1 2+ `Answer: Π`

```

returns `Answer: 3`

As always, you can escape `Π` by using a backlash.

---
Tags: code-golf, tips, vyxal
---