Brain-Flak, 90(削除) 90 (削除ここまで) 82 bytes
(((([(()()()){}()){}){}()){})(([()()()])({}){}){(({}<({}[()])>)<{({}()<(({}))>)}>{}())}{}[{}Explanation:
To set up we push the ASCII code for : (one more than 9) and the integer -9 for our counter.
(((]((()()()){}()){}){}()){})(([()()()])({}){})Then we begin our loop. In our loop we start by decrementing the top character on the stack.
{ Loop
(({}< Pick up counter
({}[()]) Decrement character
>) Put counter down
Then we duplicate the top character \$n\$ times where \$-n\$ is the value of our counter.
< Silently
{({}()< Loop n times
(({})) Duplicate a char
>)}{} end loop
> end silent
This makes \$n+1\$ copies of the desired number, which is needed since at the start of our next loop we are going to decrement the last one.
At this point we finish off the loop by incrementing the counter.
())}{}
Once out of the loop the last thing we have to do is remove the extra 1 that was created.Try it online!
{}
Explanation:
Strange delimiters, 8078 bytes
((((([(()()()){})({}){}]){}())[(({})()<([{})]){(({}((()<()()){})[({})]{}){})>)<{({}()<(({}))>)}>{})}
If we decide to play around with our delimiters a bit, we can shave off 104 bytes. This version outputs the correct stuff but with atwo leading null bytebytes and a trailingnull bytes between the chunks:
::::::::::;;;;;;;;;;;<<<<<<<<<<<<=============>>>>>>>>>>>>>>???????????????@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^_______________________________________________````````````````````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab
This is definitely a littletiny bit cheaty but as far as I can tell 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.
Brain-Flak, 90 bytes
(((((()()()){}()){}){}()){})(([()()()])({}){}){(({}<({}[()])>)<{({}()<(({}))>)}>{}())}{}{}Explanation:
To set up we push the ASCII code for : (one more than 9) and the integer -9 for our counter.
(((((()()()){}()){}){}()){})(([()()()])({}){})Then we begin our loop. In our loop we start by decrementing the top character on the stack.
{ Loop
(({}< Pick up counter
({}[()]) Decrement character
>) Put counter down
Then we duplicate the top character \$n\$ times where \$-n\$ is the value of our counter.
< Silently
{({}()< Loop n times
(({})) Duplicate a char
>)}{} end loop
> end silent
This makes \$n+1\$ copies of the desired number, which is needed since at the start of our next loop we are going to decrement the last one.
At this point we finish off the loop by incrementing the counter.
())}{}
Once out of the loop the last thing we have to do is remove the extra 1 that was created.
{}
Strange delimiters, 80 bytes
((((((()()()){}){}){}){}())[(({}){})]){(({}()<(({})[()])>)<{({}()<(({}))>)}>{})}
If we decide to play around with our delimiters a bit, we can shave off 10 bytes. This version outputs the correct stuff but with a leading null byte and a trailing:
::::::::::;;;;;;;;;;;<<<<<<<<<<<<=============>>>>>>>>>>>>>>???????????????@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^_______________________________________________````````````````````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab
This is definitely a little cheaty but as far as I can tell it meets the specs of the challenge.
Brain-Flak, (削除) 90 (削除ここまで) 82 bytes
([(()()())({}){}]){((({})()<([{}]((((()()()){}){}){}){})>)<{({}()<(({}))>)}{}>)}{}
Explanation:
Strange delimiters, 78 bytes
([(()()())({}){}]){((({})()<([{}]((((()()()){}){}){}){})>)<{({}()<(({}))>)}>)}
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.
Strange delimiters, 80 bytes
((((((()()()){}){}){}){}())[(({}){})]){(({}()<(({})[()])>)<{({}()<(({}))>)}>{})}
If we decide to play around with our delimiters a bit, we can shave off 10 bytes. This version outputs the correct stuff but with a leading null byte and a trailing:
::::::::::;;;;;;;;;;;<<<<<<<<<<<<=============>>>>>>>>>>>>>>???????????????@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^_______________________________________________````````````````````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab
This is definitely a little cheaty but as far as I can tell it meets the specs of the challenge.
Strange delimiters, 80 bytes
((((((()()()){}){}){}){}())[(({}){})]){(({}()<(({})[()])>)<{({}()<(({}))>)}>{})}
If we decide to play around with our delimiters a bit, we can shave off 10 bytes. This version outputs the correct stuff but with a leading null byte and a trailing:
::::::::::;;;;;;;;;;;<<<<<<<<<<<<=============>>>>>>>>>>>>>>???????????????@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^_______________________________________________````````````````````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab
This is definitely a little cheaty but as far as I can tell it meets the specs of the challenge.
Brain-Flak, 90 bytes
(((((()()()){}()){}){}()){})(([()()()])({}){}){(({}<({}[()])>)<{({}()<(({}))>)}>{}())}{}{}
Explanation:
To set up we push the ASCII code for : (one more than 9) and the integer -9 for our counter.
(((((()()()){}()){}){}()){})(([()()()])({}){})
Then we begin our loop. In our loop we start by decrementing the top character on the stack.
{ Loop
(({}< Pick up counter
({}[()]) Decrement character
>) Put counter down
Then we duplicate the top character \$n\$ times where \$-n\$ is the value of our counter.
< Silently
{({}()< Loop n times
(({})) Duplicate a char
>)}{} end loop
> end silent
This makes \$n+1\$ copies of the desired number, which is needed since at the start of our next loop we are going to decrement the last one.
At this point we finish off the loop by incrementing the counter.
())}{}
Once out of the loop the last thing we have to do is remove the extra 1 that was created.
{}
Compare this with the output of JoKing's autogolfer
Brain-Flak, 142 bytes
(((((((((((((((((((((((((((((((((((((((((((((((((()()()){}){}){}){}())()))())))()))))())))))()))))))())))))))()))))))))()))))))))){({}<>)<>}<>
Brain-Flak, 90 bytes
(((((()()()){}()){}){}()){})(([()()()])({}){}){(({}<({}[()])>)<{({}()<(({}))>)}>{}())}{}{}
Compare this with the output of JoKing's autogolfer
Brain-Flak, 142 bytes
(((((((((((((((((((((((((((((((((((((((((((((((((()()()){}){}){}){}())()))())))()))))())))))()))))))())))))))()))))))))()))))))))){({}<>)<>}<>
Brain-Flak, 90 bytes
(((((()()()){}()){}){}()){})(([()()()])({}){}){(({}<({}[()])>)<{({}()<(({}))>)}>{}())}{}{}
Explanation:
To set up we push the ASCII code for : (one more than 9) and the integer -9 for our counter.
(((((()()()){}()){}){}()){})(([()()()])({}){})
Then we begin our loop. In our loop we start by decrementing the top character on the stack.
{ Loop
(({}< Pick up counter
({}[()]) Decrement character
>) Put counter down
Then we duplicate the top character \$n\$ times where \$-n\$ is the value of our counter.
< Silently
{({}()< Loop n times
(({})) Duplicate a char
>)}{} end loop
> end silent
This makes \$n+1\$ copies of the desired number, which is needed since at the start of our next loop we are going to decrement the last one.
At this point we finish off the loop by incrementing the counter.
())}{}
Once out of the loop the last thing we have to do is remove the extra 1 that was created.
{}
Compare this with the output of JoKing's autogolfer
Brain-Flak, 142 bytes
(((((((((((((((((((((((((((((((((((((((((((((((((()()()){}){}){}){}())()))())))()))))())))))()))))))())))))))()))))))))()))))))))){({}<>)<>}<>