27
\$\begingroup\$

Numbers by Position

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

This prints out the numbers with a space delimiter:

1 22 333 4444 55555 666666 7777777 88888888 999999999

Challenge Type

, so shortest answer in bytes (by language) wins.

Based on a submission in the sandbox.

\$\endgroup\$
  • 2
    \$\begingroup\$ Can the delimeters be numbers? \$\endgroup\$ – Ad Hoc Garf Hunter Mar 17 at 17:16
  • \$\begingroup\$ @AdHocGarfHunter, No. Good catch. Edit: Actually, I think '0' should be acceptable. \$\endgroup\$ – ouflak Mar 17 at 17:17
  • \$\begingroup\$ Could you verify that they "strange delimiters" version of this answer, is valid? It definitely seems cheaty. \$\endgroup\$ – Ad Hoc Garf Hunter Mar 17 at 17:32
  • \$\begingroup\$ Honestly I think it's a clever 'outside-of-the-box' solution. I'd upvote, but I'm out of votes until tomorrow. \$\endgroup\$ – ouflak Mar 17 at 17:35
  • 2
    \$\begingroup\$ @ouflak Thanks for the algorithm guide! How did you know I always write my prototypes with Turing Machines :p \$\endgroup\$ – AviFS Mar 19 at 1:01

73 Answers 73

14
\$\begingroup\$

05AB1E, 3 bytes

9L×

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
| improve this answer | |
\$\endgroup\$
24
\$\begingroup\$

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

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ I've run out of votes. \$\endgroup\$ – ouflak Mar 17 at 12:37
  • \$\begingroup\$ @ouflak Darn... \$\endgroup\$ – S.S. Anne Mar 17 at 13:18
15
\$\begingroup\$

Bash + Core utilities, 27, 25 bytes

seq -f8d%f*7-v1+2/n 45|dc

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.

| improve this answer | |
\$\endgroup\$
10
\$\begingroup\$

Python 2, 28 bytes

i=1;exec"print`i`*i;i+=1;"*9

Try it online!

| improve this answer | |
\$\endgroup\$
8
\$\begingroup\$

Kotlin, 30 bytes

{(1..9).map{"$it".repeat(it)}}

Try it online!

| improve this answer | |
\$\endgroup\$
8
\$\begingroup\$

R, 18 bytes

a=1:9;(10^a-1)/9*a

Try it online!

Use the formula \$\frac{10^n-1}{9}\times n\$ for the \$n\$th number.

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Hmm, I may be out of date but isn't the usual ruling that it needs cat() or equivalent to print the output? \$\endgroup\$ – user2390246 Mar 17 at 16:44
  • 1
    \$\begingroup\$ @user2390246 yeah, the consensus was changed...a while ago? Late 2017 by my quick search of meta. This is probably what you're aware of but taking that approach with this meta post on compiler flags basically means all R answers are just "R invoked with source(...,echo=TRUE)" \$\endgroup\$ – Giuseppe Mar 17 at 18:44
  • \$\begingroup\$ @Giuseppe thanks for the clarification, I've not been around for a while! Seems like the trend for cat()-type answers ended up being quite a short phase then. \$\endgroup\$ – user2390246 Mar 17 at 19:33
  • \$\begingroup\$ Beat you with a string-only approach! :-) \$\endgroup\$ – Giuseppe Mar 18 at 19:07
  • \$\begingroup\$ @Giuseppe Ooh, nice! \$\endgroup\$ – Robin Ryder Mar 18 at 19:16
7
\$\begingroup\$

APL (dzaima/APL), 6 bytes

Full program, requiring ⎕IO←0.

⍋⍛⌿⍨⎕D

Try it online!

⎕D on the string "0123456789",

⍛⌿⍨ replicate the characters by

 their grade (0, 1, 2, …, 9)

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Isn't \⍨⍳9 at 4 bytes sufficient? I've added it as my own answer, though it doesn't seem to be gaining any traction. Would love feedback! \$\endgroup\$ – AviFS Mar 19 at 0:58
  • \$\begingroup\$ @AviF.S. It wasn't clear that this was a permitted format, but now that OP has clarified, you have my upvote. \$\endgroup\$ – Adám Mar 19 at 6:52
6
\$\begingroup\$

brainfuck, 56 bytes

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

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
]
| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ 50 bytes \$\endgroup\$ – Jo King Mar 17 at 9:22
  • \$\begingroup\$ Thank you. Your code is so different from mine, you should post it as a separate answer. \$\endgroup\$ – Dorian Mar 17 at 13:27
5
\$\begingroup\$

Retina, 12 bytes


9*

$.`*$.`

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.

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ The leading _ is absolutely acceptable. \$\endgroup\$ – ouflak Mar 17 at 11:31
5
\$\begingroup\$

Haskell, 30 29 bytes

(<$)<*>g<$>g '9'
g c=['1'..c]

Try it online!

| improve this answer | |
\$\endgroup\$
5
\$\begingroup\$

Brain-Flak, 90 82 bytes

([(()()())({}){}]){((({})()<([{}]((((()()()){}){}){}){})>)<{({}()<(({}))>)}{}>)}{}

Try it online!

Explanation:


Compare this with the output of JoKing's autogolfer

Brain-Flak, 142 bytes

(((((((((((((((((((((((((((((((((((((((((((((((((()()()){}){}){}){}())()))())))()))))())))))()))))))())))))))()))))))))()))))))))){({}<>)<>}<>

Try it online!


Strange delimiters, 78 bytes

([(()()())({}){}]){((({})()<([{}]((((()()()){}){}){}){})>)<{({}()<(({}))>)}>)}

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 is the old super cheaty version that has been made obsolete by my golfs.

| improve this answer | |
\$\endgroup\$
5
\$\begingroup\$

APL (Dyalog Unicode), 4 bytes

\⍨⍳9

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
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Feedback: I'd use /⍨⍳9 as it is simpler. / is really "replicate" while \ is the more complex "expand". \$\endgroup\$ – Adám Mar 19 at 6:53
4
\$\begingroup\$

APL (Dyalog Unicode), 7 bytesSBCS

⎕D/⍨⍳10

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
| improve this answer | |
\$\endgroup\$
4
\$\begingroup\$

R, 15 bytes

strrep(1:9,1:9)

Try it online!

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Just rep(1:9,1:9) is shorter (and gives exactly the output of the first example)? \$\endgroup\$ – Dominic van Essen Jun 24 at 22:50
4
\$\begingroup\$

[Java 11 (JDK)], 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!

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ You can save 1 byte changing the ()-> to v->, by taking an empty unused (Void null) argument, which is allowed when it's completely unused. \$\endgroup\$ – Kevin Cruijssen Mar 18 at 10:04
  • \$\begingroup\$ @Kevin Cruijssen Thanks for the suggestion, didn't know about that. I now use an Object as parameter and pass null, is this the intended way or can you actually do it with Void? \$\endgroup\$ – greinet Mar 18 at 10:26
  • \$\begingroup\$ Object null is fine as well. As long as the argument isn't used in any way, not even for static calls, it's ok. That's why I personally use Void, since it has no available static calls anyway. :) \$\endgroup\$ – Kevin Cruijssen Mar 18 at 10:27
  • \$\begingroup\$ Well thats awkward, could've sworn that it just didn't compile with type Void, changed it again and now it works, thanks. \$\endgroup\$ – greinet Mar 18 at 10:32
3
\$\begingroup\$

Icon, 27 bytes

write(1(i:=1to 9,1to i))&\z

Try it online!

| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Perl 5, 18 bytes

map{say$_ x$_}1..9

Try it online!

| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

T-SQL, 69 bytes

SELECT top 9replicate(1+number,1+number)FROM spt_values WHERE'p'=type

Try it online

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Nice code. Sometimes I wonder how well T-SQL would do in these challenges if we had a built-in number table or some equivalent to PostgreSQL's generate-series() function. \$\endgroup\$ – BradC May 26 at 15:48
  • \$\begingroup\$ @BradC normally SQL will not win in these golfing questions even with improved features. When we use a command like replicate(a,b), some of the other languages can solve problem with fewer characters than the 14 characters(minimum) it takes to call that function. The best we can do it solve the problems using a language which usually isn't optimal, and hope some people are impressed enough to up-vote those solutions. \$\endgroup\$ – t-clausen.dk May 27 at 11:29
3
\$\begingroup\$

Perl 6, 13 bytes

{1..9 Zx^9+1}

Try it online!

Anonymous code block that returns a list of strings by zip string multiplying the range 1 to 9 with itself.

| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

W 5 4 3 bytes

@π┐

Uncompressed:

$*9N

Repeat 1..9 N times.

Explanation

     M % Map in the range
9      % From 1 to 9
  a$   % Stringify the current counter
 a  *  % Repeat that string by the current counter
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Just curious, why do you have the meta link to the command line flags answer? Is that related to your implementation? \$\endgroup\$ – ouflak Mar 17 at 11:29
  • \$\begingroup\$ @ouflak No,that's was part of the copy-pasted template. \$\endgroup\$ – Third-party 'Chef' Mar 17 at 11:30
  • \$\begingroup\$ @ouflak Why is this accepted? The 05AB1E solution is posted before this answer. You should accept that instead. \$\endgroup\$ – Third-party 'Chef' Mar 24 at 12:10
  • \$\begingroup\$ Both were 3 bytes. I just flipped a coin. I can swap them.... \$\endgroup\$ – ouflak Mar 24 at 12:41
  • \$\begingroup\$ @ouflak The general consensus is that you shouldn‘t accept an answer anyway. (Appreciate I‘m a few months late, and that you can do as you please, just spreading the consensus view) \$\endgroup\$ – caird coinheringaahing Jun 23 at 23:47
3
\$\begingroup\$

Erlang (escript), 49 bytes

f()->[X*(math:pow(10,X)-1)/9||X<-lists:seq(1,9)].

Try it online!

| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

C (gcc), 50 bytes

n;f(i){for(i=0;i++<9;)for(n=i;n--;)putchar(48+i);}

Try it online!

| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Haskell, 21 bytes

[c<$[1..c]|c<-[1..9]]

Try it online!

A list of lists of numbers.

23 bytes

replicate<*>id=<<[1..9]

Try it online!

A flat list of nubers.

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ I think that the delimiter has to be in between differing digits (e.g. 1 and 2 as opposed to 8 and another 8). \$\endgroup\$ – Ad Hoc Garf Hunter Mar 17 at 18:06
  • \$\begingroup\$ @AdHocGarfHunter Looking again at the challenge, I'm not clear on this so I asked. I think it would be unfortunate if the flat list in the second version were invalid too. \$\endgroup\$ – xnor Mar 17 at 18:14
3
\$\begingroup\$

Japt, 4 bytes

AÇîZ

Try it

NaN
| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Stax, 5 bytes

╜├ìíy

Try it online or try it online unpacked (6 bytes).

Explanation (of the unpacked version):

Vd      # Push constant "0123456789"
  A     # Push 10
   r    # Pop and push a list in the range [0, 10)
    :B  # Repeat the characters in the string the integer amount of times:
        #  "122333444455555666666777777788888888999999999"
        # (after which the top of the stack is output implicitly as result)
| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Japt -P, 5 4 bytes

AÇçZ

Test it

| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

J, 18 bytes

echo u:(#48+])i.10

Try it online!

K (oK), 11 10 bytes

-1 byte thanks to ngn!

,/${x}#!10

Try it online!

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ ,/${x}#!10 - using filter ({ }#) for replication \$\endgroup\$ – ngn Mar 25 at 19:23
  • \$\begingroup\$ @ngn Thanks, of course! \$\endgroup\$ – Galen Ivanov Mar 25 at 19:28
3
\$\begingroup\$

[VBA] 58 bytes

i=1:While i<0:For x=1 to i:Debug.Print i:Next x:i=i+1:wend

Can be ran in Immediate

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ you appear to have a typo in your code (while i<0->while i<10) \$\endgroup\$ – Taylor Scott Jun 6 at 16:20
  • \$\begingroup\$ You can get your code down quite a bit by using nested for loops and by using ? in place of debug.print - For i=1To 9:For j=1To i:?i:Next j,i for 35 bytes \$\endgroup\$ – Taylor Scott Jun 6 at 16:22
  • \$\begingroup\$ Oh - or better yet, if we use an approach similar to that of Mitchell Spector's we can get it down to 32 bytes as For i=1to 45:?(3.1*i^.48)\2:Next (or 33 bytes as For i=1to 45:?(3.1*i ^.48)\2:Next for 64-bit installs) \$\endgroup\$ – Taylor Scott Jun 6 at 17:11
2
\$\begingroup\$

Keg, 45 11 9 8 bytes

9Ï^⑷:⅍*⑸

Try it online!

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

PowerShell, 15 bytes

1..9|%{"$_"*$_}

Try it online!

| improve this answer | |
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.