60
\$\begingroup\$

This might be a very simple challenge, but I am surprised it hasn't been done on code-golf yet:

Print all Integers from 1 to 10 inclusive in ascending order to standard output.

Your output format can be whatever your language supports. This includes arbitrary separators (commas, semicolons, newlines, combinations of those, etc., but no digits), and prefixes and postfixes (like [...]). However, you may not output any other numbers than 1 through 10. Your program may not take any input. Standard loopholes are disallowed.

This is , so shortest answer in bytes wins!

Leaderboard

var QUESTION_ID=86075,OVERRIDE_USER=42570;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

\$\endgroup\$
17
  • 10
    \$\begingroup\$ Related (duplicate?) \$\endgroup\$
    – Luis Mendo
    Commented Jul 21, 2016 at 9:07
  • 17
    \$\begingroup\$ If the only change is hard-coding a single parameter then that falls under the banner of "trivial change", and by the standards of this site still counts as a dupe. \$\endgroup\$ Commented Jul 21, 2016 at 9:54
  • 11
    \$\begingroup\$ @PeterTaylor The other challenge has a huge problem with the integer limits though. The way it's specified every TC language that doesn't have 64-bit integers needs to implement them. (And that affects quite a lot of languages.) \$\endgroup\$ Commented Jul 21, 2016 at 10:01
  • 20
    \$\begingroup\$ @xnor Quite frankly, I'd rather close the other challenge as a duplicate of this one. The requirement pretty much ruins it. \$\endgroup\$
    – Dennis
    Commented Jul 21, 2016 at 14:09
  • 11
    \$\begingroup\$ I can't believe every single of the (currently) 71 answers assumes the base should be decimal… \$\endgroup\$ Commented Jul 22, 2016 at 15:05

273 Answers 273

1 2 3
4
5
10
2
\$\begingroup\$

Kotlin, 16 bytes

print((1..9)+10)

Beautified

print((1..9)+10)

Test

fun f() =
print((1..9)+10)

fun main(args: Array<String>) {
    f()
}

TIO

TryItOnline

\$\endgroup\$
2
\$\begingroup\$

brainfuck, 53 bytes

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

Try it online!

Explanation :

++++++++++              # set initial counter to ten
[->+++++>+>+<<<]        # creates ascii cell, second counter, and newline
>-->-                   # fixes ascii and counter cell values
[-<+.>>.<]              # prints digits one through nine
<--------.-.            # prints the ten

Output:

1
2
3
4
5
6
7
8
9
10
\$\endgroup\$
2
  • \$\begingroup\$ It's not really different enough from the previous answer for me to upvote, but I appreciate the explanation. Also, this answer is much shorter \$\endgroup\$
    – Jo King
    Commented Feb 21, 2018 at 3:49
  • 1
    \$\begingroup\$ And welcome to PPCG! \$\endgroup\$
    – Jo King
    Commented Feb 21, 2018 at 3:56
2
\$\begingroup\$

Keg, 12 bytes

1(91+|:. ,1+

Output is separated by spaces

How it works

1   Pushes 1
(   Begins for loop
91+|   For loop will run 10 times
:.     Output the top element of the stack
 ,     Output space
1+     Add one to the top element of the stack
End bracket gets added automaticly

Try it Online!

\$\endgroup\$
10
  • \$\begingroup\$ I am working on supporting \ in loop conditions as in this (1 byte less) \$\endgroup\$
    – user85052
    Commented Aug 10, 2019 at 13:54
  • \$\begingroup\$ Oh yeah, I did try that and was wondering why that wasn't working, but I just compromised with 91+ \$\endgroup\$
    – EdgyNerd
    Commented Aug 10, 2019 at 13:57
  • \$\begingroup\$ That isn't working because you can't escape a character in a for loop repetition indicator. If you read the implementation, you will find that the escaping character is simply skipped. (I just created a PR for it. JonoCode9374 will probably merge it.) \$\endgroup\$
    – user85052
    Commented Aug 10, 2019 at 14:00
  • \$\begingroup\$ Whoops, there is an issue in my source code that makes it in fact 2 bytes less. (A 1-to-10-printing program written using 10 bytes!) \$\endgroup\$
    – user85052
    Commented Aug 10, 2019 at 14:05
  • \$\begingroup\$ Should we create a Keg chatroom to discuss new features and golfing? \$\endgroup\$
    – EdgyNerd
    Commented Aug 10, 2019 at 14:31
2
\$\begingroup\$

Clojure REPL, 12 bytes

(range 1 11)

I think this is self explanatory code

\$\endgroup\$
2
  • 1
    \$\begingroup\$ Hello and welcome to PPCG. The challenge asks for a program to output to stdout, meaning you either need to add println or potentially declare your language as "Clojure REPL" per standard rules. \$\endgroup\$ Commented Sep 17, 2019 at 7:25
  • \$\begingroup\$ Oh I see, thank you \$\endgroup\$
    – Ampersanda
    Commented Sep 18, 2019 at 1:30
2
\$\begingroup\$

Turing Machine Language, 199 bytes

0 * 1 r 1
1 _ _ r 2
2 * 2 r 3
3 _ _ r 4
4 * 3 r 5
5 _ _ r 6
6 * 4 r 7
7 _ _ r 8
8 * 5 r 9
9 _ _ r a
a * 6 r b
b _ _ r c
c * 7 r d
d _ _ r e
e * 8 r f
f _ _ r g
g * 9 r h
h _ _ r i
i * 1 r j
j * 0 r k

Try it online!

\$\endgroup\$
2
\$\begingroup\$

Putt, 2 bytes

X:
X # Roman Numeral for 10
 : # Ranger operator pushes [1..N]
    # Putt implicitly prints
\$\endgroup\$
2
\$\begingroup\$

Hexadecimal Stacking Pseudo-Assembly Language, 54 bytes

203039400000120000201A8540000012000020000A400000120000

Try it online!

203039 input 0x3039 (decimal 12345)
400000 push that on stack
120000 print it
201A85 input 0x1A85 (decimal 6789)
400000 push that on stack
120000 print it
20000A input 0xA (decimal 10)
400000 push that on stack
120000 print it
\$\endgroup\$
2
\$\begingroup\$

BrainFuck, 41 Bytes

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

Output

12345678910

Try it online

\$\endgroup\$
2
\$\begingroup\$

naz, 50 bytes

1x1f1a1o2x1v0m9a1a1o1v0x1f1f1f1f1f1f1f1f1f8s1o1s1o

Explanation (with 0x commands removed)

1x1f                   # Function 1
    1a1o               # Add 1 to the register and output
        2x1v           # Store the new value in variable 1
            0m9a1a1o   # Output a newline
                    1v # Read variable 1 into the register
1f1f1f1f1f1f1f1f1f     # Call function 1 nine times
8s1o                   # Subtract 8 and output
1s1o                   # Subtract 1 and output
\$\endgroup\$
2
\$\begingroup\$

Commodore BASIC, method 1 (28 bytes)

0?1,2,3,4,5,6,7,8,9,10

Method 2 (27 26 bytes)

0FORI=1TO10:?I:NEXT

Method 3 (40 39 bytes)

0I=1
1?I:I=I+1:IFI<11THEN1

Method 4 (32 31 bytes)

0?I:I=I+1:IFI<11THEN0
I=1:GOTO0

Method 5 (20 bytes)

0?"12345678910

Method 6 (25 bytes) CBM BASIC V2 only [C64/C64Mini or VIC-20]

0I=I+1:?I:ON-(I<10)GOTO

I'm working out the memory used with ? 38911-(fre(0)-65536*(fre(0)<0)) on a Commodore 64.

\$\endgroup\$
2
\$\begingroup\$

W, 2 bytes

Tk

Constant 10, then range from 1 to that. Added for completeness.

\$\endgroup\$
2
\$\begingroup\$

Flurry, 38 bytes

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

Verification

$ ./flurry -inn -c "<({<({})({}){}>}){}>{(<><<>()>{})}({})"
1 2 3 4 5 6 7 8 9 10

Since multiplication and exponentiation is much cheaper than increment, addition, and high number literals, 9 (being 3**2 or 3*3) is much cheaper to produce than 10. Since producing 1 is almost free (via popping from empty stack), I push a 1 manually and then loop 9 times to push 2 through 10. Then the stack is printed in integer mode, from bottom to top.

<({<({})({}){}>}){}>  Number 9
<...>  Function composition (multiply numbers)
 (...)  Push and return the number inside...
  {<({})({}){}>}  The number literal 3
 {}     Pop 3 back
       evaluates to 3 * 3 = 9

{(<><<>()>{})}  Lambda function: Increment, push and return
{...}  Lambda, which implicitly pushes its argument
 (...)  Push and return the result of...
  <><<>()>  Increment
  {}        the argument

({})  Initial value 1, pushed to the stack

The entire program is roughly 9 (\x. push (succ x)) (push 1)
\$\endgroup\$
2
\$\begingroup\$

Grok, 13 bytes

}q
{p1+YzP9>!
\$\endgroup\$
2
\$\begingroup\$

Vyxal, 2 bytes

₀ɾ

Try it Online!

Explanation:

₀   # 10
 ɾ  # Range [1, N]
    # Implicit output
\$\endgroup\$
2
\$\begingroup\$

BRASCA, 9 bytes

1lr,[nlo]

Try it!

Explanation

1lr         - Push range(1,10) to the stack
   ,        - Reverse the stack
    [   ]   - While the stack isnt empty: 
     n      -   Output the next number...
      lo    -   and a newline!
\$\endgroup\$
2
\$\begingroup\$

CSASM v2.4.0.2, 43 bytes

func main:
push [1..10]
conv ~arr
print
ret
end

Prints [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] to the console.

Explanation:

func main:
    ; Push a Range
    push [1..10]
    ; Convert it to an array: [1..10] -> [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
    conv ~arr
    ; Print the CSASM representation of that array
    print
    ret
    end
end

If the output had to only be the numbers 1 through 10, that would be this 72 byte program:

func main:
lda 1
.lbl a
push $a
print.n
inc $a
push 11
push $a
sub
brtrue a
ret
end

Explanation:

func main:
    ; Store 1 into $a
    lda 1

    .lbl a
        ; Print $a
        push $a
        print.n

        ; Stop looping if 11 - ++$a == 0
        inc $a
        push 11
        push $a
        sub
        brtrue a
    ret
end
```
\$\endgroup\$
2
\$\begingroup\$

Hexagony, 16 bytes

9{$:':</)!'/>;}}

Try it online!

Expanded:

   9 { $
  : ' : <
 / ) ! ' /
  > ; } }
   . . .

Admittedly, this solution feels a bit questionable. Its output is

123456789	10

This is each number from 1 to 10, separated by the Unicode characters of their values. So, for example, 9 and 10 are separated by tab, which is Unicode character 9. Technically the problem doesn't specify that all the separators must be the same, though perhaps its implied. If you feel this is invalid, here's a 17 byte version that uses lowercase e as a separator (nothing special about e, it can be any character that isn't a special character in Hexagony).

9{.e:'<)!'://}};>

Here's another 17 byte alternate that prints the numbers separated by newlines, but never terminates (it prints 1 to 10 and then runs forever without printing anything else).

_10<>-<{)!'//=;{>

I'll just explain the 16 byte code because the others are just minor variations on it. Starting in the top left and moving right, 9}$ writes nine into a memory slot, then moves to an adjacent memory slot, and uses $ to jump into the main loop on line 3. The main loop starts with )!, which increments the value in the current memory slot and then prints its decimal value. This cell will cycle through the values 1 to 10, printing each. Then, ': backs up to a new memory slot and divides 9 by the number that was just printed. Because Hexagony uses integer division, the result will be one as long as the number is less than or equal to 9, and 0 once its greater. This gives a termination condition, as another ': backs into an empty slot and divides 0 by this number. As long as this value as 1 this calculation will be inconsequential, but when it equals zero, the program will crash trying to divide by zero. After this, }}; moves back to the incrementing memory slot, prints it as a Unicode value, and then reenters the main loop.

\$\endgroup\$
2
  • \$\begingroup\$ Welcome to Code Golf, and nice first answer! IMO "Your output format can be whatever your language supports. This includes arbitrary separators" means that this format is perfectly acceptable, but if you're really concerned, you can leave a comment below the question asking once you've reached 50 reputation. I've edited your answer to include the unprintable characters \$\endgroup\$ Commented Apr 26, 2021 at 19:44
  • \$\begingroup\$ @cairdcoinheringaahing Ah cool, thanks! \$\endgroup\$
    – je je
    Commented Apr 26, 2021 at 19:48
2
\$\begingroup\$

Knight, 16 bytes

;=w 0W>10wO=w+1w

Try it online!

# set w to 0
; = w 0
# loop while w < 10
: WHILE > 10 w
   # Output ++w
   : OUTPUT (= w + 1 w)
\$\endgroup\$
2
\$\begingroup\$

Japt, 2 bytes

Test it

Aõ
A     :10
 õ    :Range [1,A]
\$\endgroup\$
2
\$\begingroup\$

dotcomma, 67 bytes

[[[[[[[[[[.,][.].,][.].,][.].,][.].,][.].,][.].,][.].,][.].,][.].,]

The shortest is the direct approach: Put a 1 on queue and then, nine times put the previous value plus 1 on the queue. Output implicitly.

<script src="https://combinatronics.com/Radvylf/dotcomma/master/interpreter.js"></script><script src="https://code.jquery.com/jquery-3.5.1.min.js"></script><script>$(document).ready(function () {$("#btnInterpret").click(function () {$("#txtResult").text(interpret($("#txtCode").val(), $("#txtInput").val(), $("#lstOutputAs").children("option:selected").val()));});});</script><style>.textBox {background-color: white;border: 1px solid black;font-family: Courier New, Courier, monospace;width: 100%;}</style>Code: <textarea id="txtCode" type="text" class="textBox" style="height: 200px">[[[[[[[[[[.,][.].,][.].,][.].,][.].,][.].,][.].,][.].,][.].,][.].,]</textarea><br />Input: <textarea id="txtInput" type="text" class="textBox"></textarea><br /><input id="btnInterpret" type="button" value="Run" />Output as: <select id="lstOutputAs"><option value="">Number array</option><option value="true">String</option></select><br />Result:<br /><div id="txtResult" class="textBox" style="overflow-wrap: break-word"></div>

\$\endgroup\$
2
\$\begingroup\$

Swift 5.6, 18 bytes

print([_](1...10))

SwiftFiddle link, since TIO uses Swift 5.0.

Same method as this Swift 3 answer, but using a new syntax for type inference. [Int] is short for Array<Int>, and Array<_> means "an array, but infer the element type" (mostly the same as just Array). Therefore, [_] is short for Array. Go figure.

\$\endgroup\$
2
\$\begingroup\$

Cognate, 16 bytes

Print Range 1 11

Attempt This Online!

Pretty self-explanatory, but here's a fuller version:

Print the Range of numbers from 1 up to but not including 11

(Lowercase words are treated as comments.)

\$\endgroup\$
2
\$\begingroup\$

Regenerate -a, 8 bytes

[1-9]|10

Attempt This Online!

\$\endgroup\$
0
2
\$\begingroup\$

Java, 47 bytes

()->{for(int i=0;i++<10;System.out.print(i));};

Ungolfed test program

public static void main(String[] args) {
    Runnable r = () -> {
        for (int i = 0; i++ < 10; System.out.print(i));
    };

    r.run();
}

36 bytes + imports

()->IntStream.range(0,11).toArray();

Doesn't include imports :(

\$\endgroup\$
2
\$\begingroup\$

J-uby, 4 bytes

10.+

In J-uby, n.+ is the same as [*1..n].

\$\endgroup\$
6
  • \$\begingroup\$ So, what is J-uby? Is it like Ruby's analog of Pyth, combined with J or something like that? \$\endgroup\$
    – Adalynn
    Commented Jun 19, 2017 at 20:41
  • \$\begingroup\$ @ZacharyT it's not like pyth. J-uby is an extension of ruby that gives it concise fictional programming features in the style of J. I'm now adding other methods as aliases to make it more suitable for code golfing. The most important principle is that any valid Ruby code is valid J-uby code. \$\endgroup\$
    – Cyoce
    Commented Jun 19, 2017 at 20:45
  • \$\begingroup\$ (It's not fictional, it's functional). So it's just somewhat like the Babel ES6 transpiler, in the fact that it converts J-uby code to Ruby? \$\endgroup\$
    – Adalynn
    Commented Jun 19, 2017 at 20:47
  • \$\begingroup\$ @ZacharyT auto correct is annoying. And since Ruby is awesome, you can just require 'juby' and then it is a j-uby program through metaprogramming. \$\endgroup\$
    – Cyoce
    Commented Jun 19, 2017 at 20:52
  • \$\begingroup\$ Yeah, I love how you used Ruby's wacky language features to enhance it. I wonder what someone could do with Perl this way, considering you can define new operators? \$\endgroup\$
    – Adalynn
    Commented Jun 19, 2017 at 21:02
2
\$\begingroup\$

Pushy, 3 bytes

TR_

It's extremely simple:

T  % Push 10
R  % Generate range (1 to 10, including both endpoints)
_  % Output representation of stack (1 2 3 4 5..)
\$\endgroup\$
2
\$\begingroup\$

Python 3, 24 19 bytes

print(*range(1,11))

Explanation:

       range(1,11)  # numbers 1 to 10
      *             # splat to print
print(            ) # print the numbers out
\$\endgroup\$
2
\$\begingroup\$

Nibbles, 1.5 bytes (3 nibbles)

,10

Program saved on disk conists of the 3 hex nibbles d1f:
d = , literal code = range 1..
1 = encode integer
f = integer value 10

enter image description here

Note that Nibbles appends a 6-nibble, not part of the program code, to pad the saved file to a whole number of bytes.

\$\endgroup\$
2
\$\begingroup\$

Piet + ascii-piet, 24 bytes (3×9=27 codels)

utqrnFecnnneutMj?lkad mm

Try Piet online!

Outputs ?1?2?3?4?5?6?7?8?9?10 where each ? is \x08. Uses 8 as the separator and the test to leave the loop (>8).

The position of the arrow is a little weird, but it starts at the top left corner facing right. Since the stack is initially empty, the first loop has a bunch of no-ops at random places, and the separator itself is on the stack when it hits DP+ the first time. If the separator is 9, then it goes to the exit path right away.

+ dup dup outN    [] no-ops
4 dup + dup outC  [8] print ascii 8
>                 [8] no-op
DP+               [] keep in the direction because 8 % 4 == 0

1 + can be used as a pattern to initialize the loop with a 1 and increment each loop.

1 +           [n] start loop with a number
dup dup outN  [n n] print n as a number
4 dup +       [n n 8]
dup outC >    [n n>8] print ascii 8 and make a boolean
DP+           [n] turn to the exit path if n > 8 (after 9 is printed)

Now we can print 10 and exit.

roll      [9] no-op; dummy cmd due to fixed colors
1 + outN  [] print 10 and exit

I tried to think of some dark magic approaches like "divide the number by 5, use DP+ at the lower left corner and end the program at the lower right corner" (since DP+ 0 and 1 would lead back to the start while 2 would reverse the pointer direction), but I couldn't get it to work.

\$\endgroup\$
2
\$\begingroup\$

Labyrinth, 14 bytes

9:"
 ("
!)
\"@

Try it online!

Prints 1 to 10 separated and terminated by newlines.

9    Push 9

:"   Loop in the order of : ( " "
("   duplicate, decrement; exit if top is 0 at (
     [9 8 7 6 5 4 3 2 1 0 | ]

!)   Loop in the order of ) ! \ "
\"   increment, print, print newline; exit if stack is empty at "

@    Halt

Labyrinth, 14 bytes

 "):
 \ !
@%0#

Try it online!

Prints 1 to 10 separated by newlines. This was the only loop I found that fits in 8 commands, which puts the halt command at a costly position.

"):   Loop in the order of " ) : ! # 0 % \
\ !   increment (pushes 1 if empty); duplicate; print;
%0#   push stack height (1); multiply by 10; mod (change 10 to 0);
      print newline
      exit at % when the number becomes zero
@     Halt
\$\endgroup\$
1 2 3
4
5
10

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

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