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.
(0..'e' as usize).for_each(|x| print!("{} ",x));
'e' as usize casts literal 'e' to its Unicode number
u32 to usize.
\$\endgroup\$
Commented
Feb 13, 2023 at 4:36
'eMºM»£'
¥
4 bytes ('eMº) if surrounding the output with brackets is allowed
'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
:_@v^O-
e]'}:
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
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 Enter 0-- - to Mark the current program position- - -.- -. dup and Konvert to Number--- to Output. - .- to Enter 1 and Add- - . .--..-.- .- dup, Enter -101 and Add--.. --. to Zeroskip until next --.- .- --. drop the unused difference and Go to marked positionTwo 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 Enter an empty cell on the stack as the string to build. --..-.- to Enter 101 so we can start the loop by decrementing-- - to Mark the start of the loop. .- .- decrement by Adding -1- - - .. -.-. .. dup, rot the string to the top and Concatenate the cells with a space in between- . --.. --. swap to get the index to the top and do a Zeroskip the the Go command that closes the loop-.- -. --- to Konvert the whole string to Number and OutputAn 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 Entering the 101 twice without wasting the bytes for stack juggling.
Finally, the best solution with 60 bytes turned out to be defining a recursive command (I used the undefined command -.):
. - - --.. -. . .- .- -. -.- -. --- . -. .-- . --..-.. -.
. [command] . -. .-- to Enter the command and Write it to address -.. --..-.. -. to Enter 100 and call the new command- - --.. -. dup and Zeroskip to the self-calling -.. .- .- decrement by Adding -1-. call itself with the decremented value-.- -. --- to Konvert to Number and Output. As this is done after calling itself, it is done first for the 0 case, to resorting is done automaticallyeXecuting 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 eXecute Again, 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!
for i=0 to asc("d")
msgbox i
Next
Competitive answer in VBScript!
for(n=0;++n<+atob`MTAx`;)alert(n)
-15 bytes thanks to @EliteDaMyth
+atob`MTAx` for 11 bytes
\$\endgroup\$
for(n=0;++n<+atob`MTAx`;)alert(n) this is 33 bytes
\$\endgroup\$
atob`MTAx`;
\$\endgroup\$
i++ into Console.WriteLine(). Try it online!
\$\endgroup\$
Commented
Feb 23, 2021 at 18:22
< rather than <=, along with the byte save from my last comment Try it online!
\$\endgroup\$
Commented
Feb 23, 2021 at 18:33
ＩＥ℅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
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.
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
Lò
This outputs a list of numbers from 0 to 100 separated by commas.
Lò
L -Number 100
ò -Creates an inclusive range from 0 to L, and return it in the output
#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!
\newcount~\loop\advance~`^^A\the~ \ifnum~<`^^%\repeat\bye
Makes uses of these two tricks:
^^A becomes NUL.
'e'{}/,`
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'{}/,' '*
Solution:
!"e"
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
#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\$.
/\\\\\/\//\\\/\/\/\/\/\/\/\/\/\/\/\///\/\\\/\/\//\\\/\
\/\\\\\\\/\
\\\/\/\\\\\\\/\\\/\\\/\\\\\\\\\\\/\/\/\\\/\\\/\\\\\\\\\\\/\/\\\\\\\/\
\\\/\/\/\\\/\///\\\\\\\\\\\//
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:
/\\\\\/\//\\\/\/\/\/\/\/\/\/\/\/\/\///\/\\\/\/\//\\\/\\\\\/\\\\\\\/\\\\\\\\\\\/\/\\\\\\\/\\\/\\\/\\\\\\\\\\\/\/\/\\\/\\\/\\\\\\\\\\\/\/\\\\\\\/\\\\\\\\\\\/\/\/\\\/\//\\/\\\\\\\\\\\//
x=True;a=x+x;b=a*a+x;print(*range(a*a*b*b+x))
Thanks to Jo King for saving 8 bytes
0Z@#@'d<l+[.a?l-z
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" }
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.
('P'..'´').joinToString(","){""+it.minus('P')}
Saving two bytes by using other chars from the ascii table that only takes one instead of two bytes.
('\n'..'n').joinToString(","){""+it.minus('\n')}
Using the ascii table to get those numbers.
When brackets are allowed at the start and end then this is smaller:
('P'..'´').map{it.minus('P')}
0::naoaa*(?!;ba-+!
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
'e'),`
Similar to the other GolfScript answer, the output has brackets, which can be removed with the following 7-byte answer:
'e'),n*
'eOR
Outputs [[0, 1, 2, ..., 99 100]].
j, \$ 6 \log_{256}(96) \approx \$ 4.94 bytes'eORAJ
Outputs 0 1 2 ... 99 100.
'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
0. Which is what makes this challenge interesting, IMO. \$\endgroup\$