[Question]
  [
**Challenge**
Print the numbers:
```
1
22
333
4444
55555
666666
7777777
88888888
999999999
```
In that order.
**I/O**
Takes no input. The numbers can have any delimiters desired (or none). That includes lists, cell arrays, .jpeg, etc.... Example outputs:
```
122333444455555666666777777788888888999999999
[1,22,333,4444,55555,666666,7777777,88888888,999999999]
etc....
```
**Code Example**
This is an un-golfed example that may perhaps act as algorithm guide (or maybe not):
# [Turing Machine Code](http://morphett.info/turing/turing.html), 535 bytes
```
0 * 1 r L
L * _ r 2
2 * 2 r a
a * 2 r M
M * _ r 3
3 * 3 r b
b * 3 r c
c * 3 r N
N * _ r 4
4 * 4 r d
d * 4 r e
e * 4 r f
f * 4 r O
O * _ r 5
5 * 5 r g
g * 5 r h
h * 5 r i 
i * 5 r j
j * 5 r P
P * _ r 6
6 * 6 r k
k * 6 r l
l * 6 r m
m * 6 r n
n * 6 r o
o * 6 r Q
Q * _ r 7
7 * 7 r p
p * 7 r q
q * 7 r r
r * 7 r s
s * 7 r t
t * 7 r u
u * 7 r R
R * _ r 8
8 * 8 r v
v * 8 r w
w * 8 r x
x * 8 r y
y * 8 r z
z * 8 r A
A * 8 r B
B * 8 r S
S * _ r 9
9 * 9 r C
C * 9 r D
D * 9 r E
E * 9 r F
F * 9 r G
G * 9 r H
H * 9 r I
I * 9 r J
J * 9 r halt
```
[Try it online!](http://morphett.info/turing/turing.html?af86c0ef679234d7861085b48ba90983)
This prints out the numbers with a space delimiter:
```
1 22 333 4444 55555 666666 7777777 88888888 999999999
```
**Challenge Type**
[code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes (by language) wins.
*Based on a [submission in the sandbox](https://codegolf.meta.stackexchange.com/questions/2140/sandbox-for-proposed-challenges/18658#18658).*
  
[Answer]
# Google Sheets, 35 bytes
```
=ArrayFormula(Rept(Row(1:9),Row(1:9
```
Sheets will automatically add three trailing parentheses when you exit the cell. Output is one line per row.
[![results](https://i.stack.imgur.com/b4IMO.png)](https://i.stack.imgur.com/b4IMO.png)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 3 bytes
```
9L×
```
[Try it online!](https://tio.run/##yy9OTMpM/f/f0ufw9P//AQ "05AB1E – Try It Online")
```
9L    Build a list from 1 to 9 {1, 2, 3, 4, 5, 6, 7, 8, 9}
×     copy each number that many times
```
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + Core utilities, ~~27~~, 25 bytes
```
seq -f8d%f*7-v1+2/n 45|dc
```
[Try it online!](https://tio.run/##S0oszvj/vzi1UEE3zSJFNU3LXLfMUNtIP0/BxLQmJfn/fwA "Bash – Try It Online")
---
*Changed seq formatting from %0.f to %f for a 2-byte savings.*
*Modified to print on one line, with no delimiters, instead of having a newline after each number, just because I like that better. Same number of bytes.*
---
This uses the formula $$\left\lfloor\frac{\big\lfloor\sqrt{8n-7}\big\rfloor+1}2\right\rfloor$$
for the \$n^{th}\$ digit, where \$n\$ goes from 1 to 45.
[Answer]
# [Python 2](https://docs.python.org/2/), 28 bytes
```
i=1;exec"print`i`*i;i+=1;"*9
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9PW0Dq1IjVZqaAoM68kITNBK9M6UxsoqKRl@f8/AA "Python 2 – Try It Online")
[Answer]
# [APL (dzaima/APL)](https://github.com/dzaima/APL), 6 bytes
Full program, requiring `⎕IO←0`.
```
⍋⍛⌿⍨⎕D
```
[Try it online!](https://tio.run/##SyzI0U2pSszMTfz/qG@qp/@jtgkGXEAWkNb4/6i3@1Hv7Ec9@x/1rgCKufzX/A8A "APL (dzaima/APL) – Try It Online")
`⎕D` on the string "0123456789",
`⍛⌿⍨` replicate the characters by
`⍋` their grade (0, 1, 2, …, 9)
[Answer]
# [Kotlin](https://kotlinlang.org), 30 bytes
```
{(1..9).map{"$it".repeat(it)}}
```
[Try it online!](https://tio.run/##DcsxDoAgDADArzTEoR0kcdSIL3DzBQxiGgGJVhfC25Hb77zEc6yf9eAmQIJ@gZUfmTe5OR4LmJpx0HokHWzKqmNR@t7TbgVZqJTq3gjBcmzXQGpJ0CFR/QE "Kotlin – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 18 bytes
```
a=1:9;(10^a-1)/9*a
```
[Try it online!](https://tio.run/##K/r/P9HW0MrSWsPQIC5R11BT31Ir8f9/AA "R – Try It Online")
Use the formula \$\frac{10^n-1}{9}\times n\$ for the \$n\$th number.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 4 bytes
```
\⍨⍳9
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT/8PBDGPelc86t1sCQA "APL (Dyalog Unicode) – Try It Online")
### How it works
```
⍳9        ⍝ Integers 1..9
   ⍨      ⍝ Duplicate argument on each side
     \    ⍝ Replicate each element *n* times
```
### Examples
```
Index Generator:    ⍳5          =  1 2 3 4 5
Expand:             2 3 \ 1 4   =  1 1 4 4 4
Commute:            +⍨4         =  4 + 4 = 8
```
[Answer]
# [Perl 5](https://www.perl.org/), 18 bytes
```
map{say$_ x$_}1..9
```
[Try it online!](https://tio.run/##K0gtyjH9/z83saC6OLFSJV6hQiW@1lBPz/L//3/5BSWZ@XnF/3V9TfUMDA0A "Perl 5 – Try It Online")
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 56 bytes
```
+++++++[>+++++++<-]+++++++++[<+[>>.<<-<+>]<[>+<-]>>>+<-]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fGwKi7aAMG91YbRiItgGK2@nZ2OjaaNvF2gDVAGXt7MDU//8A "brainfuck – Try It Online")
```
+++++++[>+++++++<-]     49 (ASCII "1")
+++++++++[              do 9 times
  <+                    add 1 to output counter
  [                     do that many times
    >>.<<               print character
    -<+>                move value of output counter to temp
  ]
  <[>+<-]               move value of temp back to output counter
  >>>+                  increment character
  <-                    decrement loop counter
]
```
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 12 bytes
```
9*
$.`*$.`
```
[Try it online!](https://tio.run/##K0otycxLNPz/n8tSi4tLRS9BC4j//wcA "Retina – Try It Online") Outputs a leading `_` to each number, which appears to be acceptable (would cost 2 bytes to fix if not). Explanation:
```
9*
```
Insert 9 `_`s.
```
$.`*$.`
```
Around each `_`, insert its position repeated appropriately.
[Answer]
# [Haskell](https://www.haskell.org/), ~~30~~ 29 bytes
```
(<$)<*>g<$>g '9'
g c=['1'..c]
```
[Try it online!](https://tio.run/##y0gszk7NyfmfZhvzX8NGRdNGyy7dRsUuXUHdUp0rXSHZNlrdUF1PLzn2f25iZp6CrUJBUWZeiUKawv9/yWk5ienF/3WTCwoA "Haskell – Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 7 bytesSBCS
```
⎕D/⍨⍳10
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkGIJaL/qPeFY96Nxsa/E8Dij3q7YNIdzUfWm/8qG0ikBcc5AwkQzw8g/@nAQA "APL (Dyalog Unicode) – Try It Online")
Uses `⎕IO←0`.
### How it works
```
⎕D/⍨⍳10
⎕D       ⍝ The string '0123456789'
  /⍨     ⍝ Replicate each of them the following times...
    ⍳10  ⍝ 0..9
```
[Answer]
# [Brain-Flak](https://github.com/Flakheads/BrainHack), ~~90~~ 82 bytes
```
([(()()())({}){}]){((({})()<([{}]((((()()()){}){}){}){})>)<{({}()<(({}))>)}{}>)}{}
```
[Try it online!](https://tio.run/##SypKzMzLSEzO/v9fI1pDQxMENTWqazWra2M1qzU0QEwNTRuNaCBfAwQgKsAKoMhO06YaqAykCqQayK@trgUT////13UEAA "Brain-Flak (BrainHack) – Try It Online")
## Explanation:
---
Compare this with the output of [JoKing's autogolfer](https://codegolf.stackexchange.com/a/157666/56656)
# [Brain-Flak](https://github.com/Flakheads/BrainHack), 142 bytes
```
(((((((((((((((((((((((((((((((((((((((((((((((((()()()){}){}){}){}())()))())))()))))())))))()))))))())))))))()))))))))()))))))))){({}<>)<>}<>
```
[Try it online!](https://tio.run/##SypKzMzLSEzO/v9fg2SgCYKa1bVwBOQBERhDCCgJo@A0goHE0qzWqK61sdO0sQOS////13UEAA "Brain-Flak (BrainHack) – Try It Online")
---
# Strange delimiters, 78 bytes
```
([(()()())({}){}]){((({})()<([{}]((((()()()){}){}){}){})>)<{({}()<(({}))>)}>)}
```
[Try it online!](https://tio.run/##SypKzMzLSEzO/v9fI1pDQxMENTWqazWra2M1qzU0QEwNTRuNaCBfAwQgKsAKoMhO06YaqAykCqQayK8Fov///@s6AgA "Brain-Flak (BrainHack) – Try It Online")
If we decide to play around with our delimiters a bit, we can shave off 4 bytes. This version outputs the correct stuff but with two leading null bytes and null bytes between the chunks:
This is a tiny bit cheaty but it meets the specs of the challenge.
---
And for posterity [here](https://tio.run/##SypKzMzLSEzO/v9fAwI0QVCzuhaOgLxoDQ0IL1azGsTU0LQBi0RrAEXsNG2qkcSA/Fo7IF37//9/XUcA "Brain-Flak (BrainHack) – Try It Online") is the old super cheaty version that has been made obsolete by my golfs.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 5 bytes
```
d´Ṙḣ9
```
[Try it online!](https://tio.run/##yygtzv7/P@XQloc7Zzzcsdjy/38A "Husk – Try It Online")
Output: `122333444455555666666777777788888888999999999`.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
9ẋ`€Ḍ
```
[Try it online!](https://tio.run/##y0rNyan8/9/y4a7uhEdNax7u6Pn/HwA "Jelly – Try It Online")
A niladic link returning a list of integers. If a program printing the numbers is preferred, subsitute `Y` for `Ḍ`.
## Explanation
```
9     | Literal 9
 ẋ`€  | Repeat each that many times
    Ḍ | Convert from decimal digits to integer
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 13 bytes
```
{1..9 Zx^9+1}
```
[Try it online!](https://tio.run/##K0gtyjH7X5xYqaDxv9pQT89SIaoizlLbsPa/pobmfwA "Perl 6 – Try It Online")
Anonymous code block that returns a list of strings by zip string multiplying the range 1 to 9 with itself.
[Answer]
# [R](https://www.r-project.org/), 15 bytes
```
strrep(1:9,1:9)
```
[Try it online!](https://tio.run/##K/r/v7ikqCi1QMPQylIHiDX//wcA "R – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 18 bytes
```
echo u:(#48+])i.10
```
[Try it online!](https://tio.run/##y/r/PzU5I1@h1EpD2cRCO1YzU8/Q4P9/AA "J – Try It Online")
# [K (oK)](https://github.com/JohnEarnest/ok), ~~11~~ 10 bytes
-1 byte thanks to ngn!
```
,/${x}#!10
```
[Try it online!](https://tio.run/##y9bNz/7/X0dfpbqiVlnR0OD/fwA "K (oK) – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 46 bytes
```
s;main(n){n>9||main(puts(memset(&s,n+48,n)));}
```
[Try it online!](https://tio.run/##S9ZNT07@/7/YOjcxM08jT7M6z86ypgbMKSgtKdbITc0tTi3RUCvWydM2sdDJ09TUtK79/x8A "C (gcc) – Try It Online")
[Answer]
# x86-16 machine code, IBM PC DOS, ~~18~~ 16 bytes
**Binary**:
```
00000000: b839 0ab2 09b1 2dcd 1048 2aca 4a75 f8c3  .9....-..H*.Ju..
```
**Listing**:
```
B8 0A39     MOV  AX, 0A39H              ; AH = 0AH, AL = '9'
B2 0A       MOV  DL, 10                 ; DL as counter value
B1 2D       MOV  CL, 1+2+3+4+5+6+7+8+9  ; start digit repeat 45 times
        NLOOP:
CD 10       INT  10H                    ; call BIOS - write digit * CX times
48          DEC  AX                     ; decrement ASCII digit
4A          DEC  DX                     ; decrement counter value
2A CA       SUB  CL, DL                 ; reduce digit repeat value by counter
75 F8       JNZ  NLOOP                  ; loop until 0 
C3          RET                         ; return to DOS
```
[Try it online!](http://twt86.co?c=uDkKsgqxLc0QSEoo0XX4ww%3D%3D)
**Explanation**:
This uses the PC BIOS API's `INT 10H` / `0AH` function to write the ASCII char in `AL` to the screen `CX` number of times. However, this function does not update the cursor position to the end of the output -- it just stays where it started. In other words, the next call simply overstrikes existing characters writing over them. Making a BIOS call to advance the cursor is expensive byte-wise.
Since going forward isn't going to work, we go backwards starting from `'9'`. It writes `'9'` 45 times, then `'8'` 36 times, `'7'` 28 times, etc -- each time starting from the first column overwriting like so:
```
999999999999999999999999999999999999999999999
888888888888888888888888888888888888999999999
777777777777777777777777777788888888999999999
666666666666666666666777777788888888999999999
555555555555555666666777777788888888999999999
444444444455555666666777777788888888999999999
333333444455555666666777777788888888999999999
222333444455555666666777777788888888999999999
122333444455555666666777777788888888999999999
```
**Output**:
[![enter image description here](https://i.stack.imgur.com/uUtKa.png)](https://i.stack.imgur.com/uUtKa.png)
[Answer]
# [Java 11 (JDK)](http://jdk.java.net/), ~~60~~ 59 bytes
Not sure if thats the shortest approach but couldn`t make it shorter even without System.out.print.
Output is without delimiters.
*-1 byte thanks to Kevin Cruijssen*
```
v->{for(int i=0;i++<9;System.out.print((i+"").repeat(i)));}
```
[Try it online!](https://tio.run/##LY7BDoIwEETvfMXG0zaExqup@AdyIfFiPNRSSLEU0pYaQ/j2WtDLTnY3M/N6HnjRN68oNHcOrlyZJQNQxkvbciGh2laAMKoGBN42CYSl25qlUYGBMobisrSjxeQCVR6ZyvPzidUf5@VAx9nTyaYXosoPB0KtnCT3qAghbI1b1DQ/tRLgPPdJ9qohgWDtk6@7P4DbzpEfiJHvnRIJNVSgmbX@46zxCw "Java (JDK) – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 21 bytes
```
[c<$[1..c]|c<-[1..9]]
```
[Try it online!](https://tio.run/##y0gszk7NyfmfbhvzPzrZRiXaUE8vObYm2UYXxLKMjf2fm5iZp2CrUFCUmVeikP7/X3JaTmJ68X/d5IICAA "Haskell – Try It Online")
A list of lists of numbers.
**23 bytes**
```
replicate<*>id=<<[1..9]
```
[Try it online!](https://tio.run/##y0gszk7Nyfmfbhvzvyi1ICczObEk1UbLLjPF1sYm2lBPzzL2f25iZp6CrUJBUWZeiUL6/3/JaTmJ6cX/dZMLCgA "Haskell – Try It Online")
A flat list of numbers.
[Answer]
# [Julia](https://julialang.org), 22 bytes
```
1:9 .|>i->show("$i"^i)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m700qzQnM3HBgqWlJWm6FtsMrSwV9GrsMnXtijPyyzWUVDKV4jI1IZJQNTC1AA)
prints
```
"1""22""333""4444""55555""666666""7777777""88888888""999999999"
```
Relying on the repl for printing output we can get to 17 bytes
```
~i="$i"^i;.~(1:9)
```
[Answer]
# [Fig](https://github.com/Seggan/Fig), \$6\log\_{256}(96)\approx\$ 4.939 bytes
```
Mcd'*_
```
[Try it online!](http://fig.fly.dev/#WyJNY2QnKl8iLCIiXQ==)
Lyxal [tried](https://codegolf.stackexchange.com/a/251799/107299) to outgolf me in my own language again.
```
Mcd'*_ # Full program
 cd    # Digits
M  '   # Map each digit string
    *  # Repeat the digit
     _ # By the number form of it
```
[Answer]
# [Deadfish~](https://github.com/TryItOnline/deadfish-), 194 bytes
```
{{i}ddddd}dc{d}{d}iiic{i}{i}ddcc{d}{d}iic{i}{i}dccc{d}{d}ic{i}{i}cccc{d}{d}c{i}{i}iccccc{d}{d}dc{i}{i}iicccccc{d}{d}ddc{i}{i}iiiccccccc{d}{d}dddc{i}{i}iiiicccccccc{d}{d}ddddc{i}{i}iiiiiccccccccc
```
[Try it online!](https://tio.run/##Tck5DoAwEEPRE3EoZINwTTnK2YcAs8Ry9T6Pnafua3M30@C7QRjHvCRM/BxlSSgKQUmA0MS0H1ObwyssJVO3NVaF@wM "Deadfish~ – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 15 bytes
```
1..9|%{"$_"*$_}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/31BPz7JGtVpJJV5JSyW@9v9/AA "PowerShell – Try It Online")
[Answer]
# [Icon](https://github.com/gtownsend/icon), 27 bytes
```
write(1(i:=1to 9,1to i))&\z
```
[Try it online!](https://tio.run/##y0zOz/tfUJSfnJpSWpSqkJuYmaeh@b@8KLMkVcNQI9PK1rAkX8FSB0RmamqqxVT9T81L@Q8A "Icon – Try It Online")
[Answer]
# T-SQL, 69 bytes
```
SELECT top 9replicate(1+number,1+number)FROM spt_values WHERE'p'=type
```
**[Try it online](https://data.stackexchange.com/stackoverflow/query/1211381/numbers-by-position)**
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 5 bytes
```
⭆χ⭆ιι
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRCO4BEil@yYWaBga6CggeJk6CpmamprW////1y3LAQA "Charcoal – Try It Online") Link is to verbose version of code. Outputs without separators. The first `StringMap` could be changed into a `for` statement for the same byte count. Explanation:
```
 χ       Predefined variable 10
⭆        Map over implicit range and join
   ι     Current index
  ⭆      Map over implicit range and join
    ι    Outer index
         Implicitly print
```
]