Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It only takes a minute to sign up.
Sign up to join this community
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.
v->java.util.stream.IntStream.range(0,'e').forEach(System.out::println)
.doSomething(v->{...}). So the Type name = form i not specific to the lambda. What is specific to the lambda is the param -> ..., hence the wide usage of lambdas in Java answers here on codegolf.
\$\endgroup\$
Feb 26, 2021 at 9:57
alert([...Array(0xB0F-0xAAA).keys()])
for(n=0;n+n<0xCA;)alert(n++)
.keys() before!
\$\endgroup\$
Feb 27, 2021 at 21:49
Sorry I overread that it's not allowed to use the characters 1-9.
I think it is really stupid to say my language can this is a shorter way, because every language today contains more than a bunch of foreign frameworks. IMHO this "bytes" should be added to the real bytes you need to print values from 0 to 100 on the screen. Therefore a good old Atari 600XL with 16kib of RAM only need: 22 bytes. No other Software is need everything is build in.
Switch the hardware on, wait 2-3sec and type: f.a=0toasc("d"):?a:n.a
'f.' is an allowed shortcut for 'for' and 'n.' is a shortcut for 'next'
Maybe the C64 need also such less bytes.
Everything else need megabytes of extra hidden bytes.
JM2C
for a=0 to asc("d"):?a:next
while(a<asc("e")):?a:a=a+!0:wend
Of course, a FOR loop is shorter than using WHILE. Thanks Lars for your example.
My earlier (apparently invalid) attempt, which got downvoted for not stopping at 100:
0 ?a:a=a+!0:goto 0
I'll leave it here for completeness - only 18 bytes though.
Now this is not going to beat some volcano in New Zealand either... that said, it would work on 8-bit computers where the entire language interpreter was on a ROM that might be 2-16 KILObytes for the whole thing. Every bytes counted (like code golf) - there certainly wasn't space to add topographical data for the developer's favourite mountain range. 😂
char e false [do] [i] . [loop]
commented:
char e \ ascii value 101
false \ 0
[do] \ loop a fixed number of times
[i] \ retrieve the iterator value
. \ print the top of the stack as a number, followed by a space
[loop] \ end of loop
'e instead of char e, and 0 is allowed in the challenge.
\$\endgroup\$
'e isn't standard. I already made another post that uses zero.
\$\endgroup\$
Mar 7, 2021 at 23:58
char e 0 [do] [i] . [loop]
commented:
char e \ ascii value 101
0
[do] \ loop a fixed number of times
[i] \ retrieve the iterator value
. \ print the top of the stack as a number, followed by a space
[loop] \ end of loop
func main:
.local a : obj
push 0
pop a
inc a
inc a
push a
inc a
inc a
inc a
push a
mul
dup
mul
pop a
lda 0
.lbl a
inc $a
push $a
dup
print.n
push a
sub
brtrue a
ret
end
Commented and ungolfed:
func main:
.local onehundred : obj
; Calculate 100
push 0
pop onehundred
inc onehundred
inc onehundred
push onehundred
; Stack: [ 2 ]
inc onehundred
inc onehundred
inc onehundred
push onehundred
; Stack: [ 2, 5 ]
mul
; Stack: [ 10 ]
dup
; Stack: [ 10, 10 ]
mul
; Stack: [ 100 ]
pop onehundred
lda 0
.lbl loop
; Print $a
inc $a
push $a
dup
print.n
; Zero is falsy. Check if $a - 100 == 0
push onehundred
sub
brtrue loop
ret
end
UC\e
Try it online!
Surprised myself by topping the previous Pyth's top score of 5 bytes.
Creates a range from 0-101 (char code of 'e' = 101)
=SEQUENCE(ROW(),,0) in A101?
\$\endgroup\$
Oct 25, 2021 at 18:57
i0<Esc><C-a>s<C-r>=r <C-r>"0<C-r>")
Explanation:
i0<Esc> # Insert `0`
<C-a> # Increment
s # Delete into register " and Insert
<C-r>= # Start expression
r # Tab-autocomplete `range(`
<C-r>" # 1
0 # 0
<C-r>" # 1
) # Full expression is `range(101)`
# Insert the range [0..101)
Alternatively (and more interesting, imo):
iYp<C-v><C-a>0<Esc>d^@=!0
00@-
Explanation:
iYp<C-v><C-a>0<Esc> # Insert `Yp<C-a>0`
d^ # Delete `Yp<C-a>`
@- # Execute `Yp<C-a>`... times
@=!0 # 1
00 # 00
class p {public static void main(String[] args){int i='A'/'A';while(i<=(int)'d')System.out.println(i++);}}}}
for(i=0;+!print(i)+'00'-i++;);
Jo king saves more bytes that I can count :)
e($!#^$_^_
@)
Explaination:
e($!#^$_^_
@)
e Pushes 101 onto the stack
( While
$ Swap
!# Output number without popping and newline
^ Top of stack = Top of stack + 1
$ Swap
_^_ Top of stack = Top of stack - 1
<newline> Push 10
@ Output top of stack as ASCII and pop
) Close while
_^_ with * is 11 as well)
\$\endgroup\$
Apr 17, 2022 at 4:34
0) @
0 \(
)#":
(!
Push 101 () is increment and 0 is "append zero" command), and run "print stack height - 1, dup, decrement" until the top becomes zero.
0)
0
)}:!
" \
@({)
Keep track of two values a=0 and b=101, print a and increment and decrement b until b becomes zero.
Filename must be x; this is for extra one byte.
echo $[x++]
a=x
((x>${#a}00))||. x
for i=0,0xA..0 do print(i)end
;echo $(0:Int('d'))
This only works in the REPL as the ; it used to enter the shell mode.
In a normal Julia file, this
println.(0:Int('d'))
works and is 20 bytes long.
If we allow the values to be printed as part of an error message, this
;$(0:Int('d'))
does it in 14.
If the printing isn't required (as Julia shows the value of the last line in the terminal) then, [0:Int('d')...] only has 15 bytes.
edit: reverted to my first solution as the improved one had a '2' in it. Oups
(0..'e' as usize).for_each(|x| print!("{} ",x));
'e' as usize casts literal 'e' to its Unicode number
u32 to usize.
\$\endgroup\$
Feb 13 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
'dR
Dropped 4 chars thanks for LyricLy(!)
Prints using LF as the delimiter by generating the list of 0-100 on the stack, then using a "print the whole stack" command.
'd - push 100 (codepoint for "d") on the stack
R - use "range" command to generate the list of numbers
- the stack prints as numbers automatically
'dR&u is 5 bytes using implicit 0 and the Range command.
\$\endgroup\$
:_@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
:`,
:`, # full program
:`,$$ # with implicit args shown;
: # join
`, # range from 0 to value minus 1:
$ # value = 100
# (if no input is given to a nibbles program,
# the variable '$' is assigned a value of 100)
$ # to 100
Note that the program :`, is the human-readable form of the code (incidentally not containing the characters 1-9).
The actual 1.5-byte Nibbles program consists of the nibbles 0111, 1011 and 0111. By default, these are saved with a 'padding' nibble of 0110 to make-up a whole number of bytes in operating systems that cannot store fractional-byte files. This could be interpreted as a 2-character program {v: note that this does not contain the characters 1-9 either.
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\$
0. Which is what makes this challenge interesting, IMO. \$\endgroup\$